Packet parsing small improvement

* correct packet readLengthEncodedString that was returning byte array to readLengthEncodedBytes
* have an readLengthEncodedString that effectively return string
* faster column parsing: MariaDB/MySQL have an identifier limitation of 64 characters (https://dev.mysql.com/doc/refman/8.4/en/identifier-length.html)

before:
BenchmarkReceiveMetadata-16         1846            650394 ns/op          138776 B/op       3024 allocs/op
after:
BenchmarkReceiveMetadata-16         1772            639809 ns/op          138776 B/op       3024 allocs/op

Author: rusher

benchmark_test.go

@@ -440,3 +440,53 @@ func BenchmarkReceiveMassiveRows(b *testing.B) {
 		}
 	})
 }
+
+// BenchmarkReceiveMetadata measures performance of receiving more metadata than real data
+func BenchmarkReceiveMetadata(b *testing.B) {
+	tb := (*TB)(b)
+	b.StopTimer()
+	b.ReportAllocs()
+
+	// Create a table with 1000 integer fields
+	createTableQuery := "CREATE TABLE large_integer_table ("
+	for i := 0; i < 1000; i++ {
+		createTableQuery += fmt.Sprintf("col_%d INT", i)
+		if i < 999 {
+			createTableQuery += ", "
+		}
+	}
+	createTableQuery += ")"
+
+	// Initialize database
+	db := initDB(b, false,
+		"DROP TABLE IF EXISTS large_integer_table",
+		createTableQuery,
+		"INSERT INTO large_integer_table VALUES ("+
+			strings.Repeat("0,", 999)+"0)", // Insert a row of zeros
+	)
+	defer db.Close()
+
+	// Prepare a SELECT query to retrieve metadata
+	stmt := tb.checkStmt(db.Prepare("SELECT * FROM large_integer_table LIMIT 1"))
+	defer stmt.Close()
+
+	b.StartTimer()
+
+	// Benchmark metadata retrieval
+	for i := 0; i < b.N; i++ {
+		rows := tb.checkRows(stmt.Query())
+
+		// Create a slice to scan all columns
+		values := make([]interface{}, 1000)
+		valuePtrs := make([]interface{}, 1000)
+		for j := range values {
+			valuePtrs[j] = &values[j]
+		}
+		rows.Next()
+		// Scan the row
+		err := rows.Scan(valuePtrs...)
+		tb.check(err)
+
+		rows.Close()
+	}
+}

packets.go

@@ -724,55 +724,40 @@ func (mc *mysqlConn) readColumns(count int) ([]mysqlField, error) {
 		}
 
 		// Catalog
-		pos, err := skipLengthEncodedString(data)
-		if err != nil {
-			return nil, err
-		}
-
+		pos := int(data[0]) + 1
 		// Database [len coded string]
-		n, err := skipLengthEncodedString(data[pos:])
-		if err != nil {
-			return nil, err
-		}
-		pos += n
+		pos += int(data[pos]) + 1
 
-		// Table [len coded string]
+		// Table alias [len coded string]
+		// alias length can be up to 256
 		if mc.cfg.ColumnsWithAlias {
 			tableName, _, n, err := readLengthEncodedString(data[pos:])
 			if err != nil {
 				return nil, err
 			}
 			pos += n
-			columns[i].tableName = string(tableName)
+			columns[i].tableName = tableName
 		} else {
-			n, err = skipLengthEncodedString(data[pos:])
+			n, err := skipLengthEncodedString(data[pos:])
 			if err != nil {
 				return nil, err
 			}
 			pos += n
 		}
 
 		// Original table [len coded string]
-		n, err = skipLengthEncodedString(data[pos:])
-		if err != nil {
-			return nil, err
-		}
-		pos += n
+		pos += int(data[pos]) + 1
 
-		// Name [len coded string]
+		// Name alias [len coded string]
 		name, _, n, err := readLengthEncodedString(data[pos:])
 		if err != nil {
 			return nil, err
 		}
-		columns[i].name = string(name)
+		columns[i].name = name
 		pos += n
 
 		// Original name [len coded string]
-		n, err = skipLengthEncodedString(data[pos:])
-		if err != nil {
-			return nil, err
-		}
-		pos += n
+		pos += int(data[pos]) + 1
 
 		// Filler [uint8]
 		pos++
@@ -843,7 +828,7 @@ func (rows *textRows) readRow(dest []driver.Value) error {
 	for i := range dest {
 		// Read bytes and convert to string
 		var buf []byte
-		buf, isNull, n, err = readLengthEncodedString(data[pos:])
+		buf, isNull, n, err = readLengthEncodedBytes(data[pos:])
 		pos += n
 
 		if err != nil {
@@ -1322,7 +1307,7 @@ func (rows *binaryRows) readRow(dest []driver.Value) error {
 			fieldTypeVector:
 			var isNull bool
 			var n int
-			dest[i], isNull, n, err = readLengthEncodedString(data[pos:])
+			dest[i], isNull, n, err = readLengthEncodedBytes(data[pos:])
 			pos += n
 			if err == nil {
 				if !isNull {

utils.go

@@ -524,10 +524,7 @@ func uint64ToString(n uint64) []byte {
 	return a[i:]
 }
 
-// returns the string read as a bytes slice, whether the value is NULL,
-// the number of bytes read and an error, in case the string is longer than
-// the input slice
-func readLengthEncodedString(b []byte) ([]byte, bool, int, error) {
+func readLengthEncodedBytes(b []byte) ([]byte, bool, int, error) {
 	// Get length
 	num, isNull, n := readLengthEncodedInteger(b)
 	if num < 1 {
@@ -543,6 +540,25 @@ func readLengthEncodedString(b []byte) ([]byte, bool, int, error) {
 	return nil, false, n, io.EOF
 }
 
+// returns the string read as a bytes slice, whether the value is NULL,
+// the number of bytes read and an error, in case the string is longer than
+// the input slice
+func readLengthEncodedString(b []byte) (string, bool, int, error) {
+	// Get length
+	num, isNull, n := readLengthEncodedInteger(b)
+	if num < 1 {
+		return "", isNull, n, nil
+	}
+
+	n += int(num)
+
+	// Check data length
+	if len(b) >= n {
+		return string(b[n-int(num) : n : n]), false, n, nil
+	}
+	return "", false, n, io.EOF
+}
+
 // returns the number of bytes skipped and an error, in case the string is
 // longer than the input slice
 func skipLengthEncodedString(b []byte) (int, error) {
@@ -567,7 +583,9 @@ func readLengthEncodedInteger(b []byte) (uint64, bool, int) {
 	if len(b) == 0 {
 		return 0, true, 1
 	}
-
+	if b[0] < 251 {
+		return uint64(b[0]), false, 1
+	}
 	switch b[0] {
 	// 251: NULL
 	case 0xfb:
@@ -582,12 +600,9 @@ func readLengthEncodedInteger(b []byte) (uint64, bool, int) {
 		return uint64(getUint24(b[1:])), false, 4
 
 	// 254: value of following 8
-	case 0xfe:
-		return uint64(binary.LittleEndian.Uint64(b[1:])), false, 9
+	default:
+		return binary.LittleEndian.Uint64(b[1:]), false, 9
 	}
-
-	// 0-250: value of first byte
-	return uint64(b[0]), false, 1
 }
 
 // encodes a uint64 value and appends it to the given bytes slice