Store prepared statements field definitions

Author: ramnes

client/stmt.go

@@ -19,6 +19,10 @@ type Stmt struct {
 	params   int
 	columns  int
 	warnings int
+
+	// Field definitions from the PREPARE response (for proxy passthrough)
+	ParamFields  []*mysql.Field
+	ColumnFields []*mysql.Field
 }
 
 func (s *Stmt) ParamNum() int {
@@ -33,6 +37,18 @@ func (s *Stmt) WarningsNum() int {
 	return s.warnings
 }
 
+// GetParamFields returns the parameter field definitions from the PREPARE response.
+// Implements server.StmtFieldsProvider for proxy passthrough.
+func (s *Stmt) GetParamFields() []*mysql.Field {
+	return s.ParamFields
+}
+
+// GetColumnFields returns the column field definitions from the PREPARE response.
+// Implements server.StmtFieldsProvider for proxy passthrough.
+func (s *Stmt) GetColumnFields() []*mysql.Field {
+	return s.ColumnFields
+}
+
 func (s *Stmt) Execute(args ...interface{}) (*mysql.Result, error) {
 	if err := s.write(args...); err != nil {
 		return nil, errors.Trace(err)
@@ -275,8 +291,14 @@ func (c *Conn) Prepare(query string) (*Stmt, error) {
 	}
 
 	if s.params > 0 {
-		for range s.params {
-			if _, err := s.conn.ReadPacket(); err != nil {
+		s.ParamFields = make([]*mysql.Field, s.params)
+		for i := range s.params {
+			data, err := s.conn.ReadPacket()
+			if err != nil {
+				return nil, errors.Trace(err)
+			}
+			s.ParamFields[i] = &mysql.Field{}
+			if err := s.ParamFields[i].Parse(data); err != nil {
 				return nil, errors.Trace(err)
 			}
 		}
@@ -290,9 +312,14 @@ func (c *Conn) Prepare(query string) (*Stmt, error) {
 	}
 
 	if s.columns > 0 {
-		// TODO process when CLIENT_CACHE_METADATA enabled
-		for range s.columns {
-			if _, err := s.conn.ReadPacket(); err != nil {
+		s.ColumnFields = make([]*mysql.Field, s.columns)
+		for i := range s.columns {
+			data, err := s.conn.ReadPacket()
+			if err != nil {
+				return nil, errors.Trace(err)
+			}
+			s.ColumnFields[i] = &mysql.Field{}
+			if err := s.ColumnFields[i].Parse(data); err != nil {
 				return nil, errors.Trace(err)
 			}
 		}

server/command.go

@@ -10,6 +10,13 @@ import (
 	"github.com/go-mysql-org/go-mysql/utils"
 )
 
+// StmtFieldsProvider is an optional interface that prepared statement contexts can implement
+// to provide field definitions for proxy passthrough scenarios.
+type StmtFieldsProvider interface {
+	GetParamFields() []*mysql.Field
+	GetColumnFields() []*mysql.Field
+}
+
 // Handler is what a server needs to implement the client-server protocol
 type Handler interface {
 	// handle COM_INIT_DB command, you can check whether the dbName is valid, or other.
@@ -112,6 +119,12 @@ func (c *Conn) dispatch(data []byte) interface{} {
 		if st.Params, st.Columns, st.Context, err = c.h.HandleStmtPrepare(st.Query); err != nil {
 			return err
 		} else {
+			// If context provides field definitions (e.g., from a backend prepared statement),
+			// use them for accurate metadata passthrough in proxy scenarios.
+			if provider, ok := st.Context.(StmtFieldsProvider); ok {
+				st.ParamFields = provider.GetParamFields()
+				st.ColumnFields = provider.GetColumnFields()
+			}
 			st.ResetParams()
 			c.stmts[c.stmtID] = st
 			return st

server/stmt.go

@@ -25,6 +25,10 @@ type Stmt struct {
 	Args []interface{}
 
 	Context interface{}
+
+	// Field definitions for proxy passthrough (optional, uses dummy fields if nil)
+	ParamFields  []*mysql.Field
+	ColumnFields []*mysql.Field
 }
 
 func (s *Stmt) Rest(params int, columns int, context interface{}) {
@@ -61,7 +65,11 @@ func (c *Conn) writePrepare(s *Stmt) error {
 	if s.Params > 0 {
 		for i := 0; i < s.Params; i++ {
 			data = data[0:4]
-			data = append(data, paramFieldData...)
+			if s.ParamFields != nil && i < len(s.ParamFields) {
+				data = append(data, s.ParamFields[i].Dump()...)
+			} else {
+				data = append(data, paramFieldData...)
+			}
 
 			if err := c.WritePacket(data); err != nil {
 				return errors.Trace(err)
@@ -76,7 +84,11 @@ func (c *Conn) writePrepare(s *Stmt) error {
 	if s.Columns > 0 {
 		for i := 0; i < s.Columns; i++ {
 			data = data[0:4]
-			data = append(data, columnFieldData...)
+			if s.ColumnFields != nil && i < len(s.ColumnFields) {
+				data = append(data, s.ColumnFields[i].Dump()...)
+			} else {
+				data = append(data, columnFieldData...)
+			}
 
 			if err := c.WritePacket(data); err != nil {
 				return errors.Trace(err)