gtsocial-umbx

data_row.go (3243B)

---

 package pgproto3
 
 import (
 	"encoding/binary"
 	"encoding/hex"
 	"encoding/json"
 
 	"github.com/jackc/pgx/v5/internal/pgio"
 )
 
 type DataRow struct {
 	Values [][]byte
 }
 
 // Backend identifies this message as sendable by the PostgreSQL backend.
 func (*DataRow) Backend() {}
 
 // Decode decodes src into dst. src must contain the complete message with the exception of the initial 1 byte message
 // type identifier and 4 byte message length.
 func (dst *DataRow) Decode(src []byte) error {
 	if len(src) < 2 {
 		return &invalidMessageFormatErr{messageType: "DataRow"}
 	}
 	rp := 0
 	fieldCount := int(binary.BigEndian.Uint16(src[rp:]))
 	rp += 2
 
 	// If the capacity of the values slice is too small OR substantially too
 	// large reallocate. This is too avoid one row with many columns from
 	// permanently allocating memory.
 	if cap(dst.Values) < fieldCount || cap(dst.Values)-fieldCount > 32 {
 		newCap := 32
 		if newCap < fieldCount {
 			newCap = fieldCount
 		}
 		dst.Values = make([][]byte, fieldCount, newCap)
 	} else {
 		dst.Values = dst.Values[:fieldCount]
 	}
 
 	for i := 0; i < fieldCount; i++ {
 		if len(src[rp:]) < 4 {
 			return &invalidMessageFormatErr{messageType: "DataRow"}
 		}
 
 		valueLen := int(int32(binary.BigEndian.Uint32(src[rp:])))
 		rp += 4
 
 		// null
 		if valueLen == -1 {
 			dst.Values[i] = nil
 		} else {
 			if len(src[rp:]) < valueLen || valueLen < 0 {
 				return &invalidMessageFormatErr{messageType: "DataRow"}
 			}
 
 			dst.Values[i] = src[rp : rp+valueLen : rp+valueLen]
 			rp += valueLen
 		}
 	}
 
 	return nil
 }
 
 // Encode encodes src into dst. dst will include the 1 byte message type identifier and the 4 byte message length.
 func (src *DataRow) Encode(dst []byte) []byte {
 	dst = append(dst, 'D')
 	sp := len(dst)
 	dst = pgio.AppendInt32(dst, -1)
 
 	dst = pgio.AppendUint16(dst, uint16(len(src.Values)))
 	for _, v := range src.Values {
 		if v == nil {
 			dst = pgio.AppendInt32(dst, -1)
 			continue
 		}
 
 		dst = pgio.AppendInt32(dst, int32(len(v)))
 		dst = append(dst, v...)
 	}
 
 	pgio.SetInt32(dst[sp:], int32(len(dst[sp:])))
 
 	return dst
 }
 
 // MarshalJSON implements encoding/json.Marshaler.
 func (src DataRow) MarshalJSON() ([]byte, error) {
 	formattedValues := make([]map[string]string, len(src.Values))
 	for i, v := range src.Values {
 		if v == nil {
 			continue
 		}
 
 		var hasNonPrintable bool
 		for _, b := range v {
 			if b < 32 {
 				hasNonPrintable = true
 				break
 			}
 		}
 
 		if hasNonPrintable {
 			formattedValues[i] = map[string]string{"binary": hex.EncodeToString(v)}
 		} else {
 			formattedValues[i] = map[string]string{"text": string(v)}
 		}
 	}
 
 	return json.Marshal(struct {
 		Type   string
 		Values []map[string]string
 	}{
 		Type:   "DataRow",
 		Values: formattedValues,
 	})
 }
 
 // UnmarshalJSON implements encoding/json.Unmarshaler.
 func (dst *DataRow) UnmarshalJSON(data []byte) error {
 	// Ignore null, like in the main JSON package.
 	if string(data) == "null" {
 		return nil
 	}
 
 	var msg struct {
 		Values []map[string]string
 	}
 	if err := json.Unmarshal(data, &msg); err != nil {
 		return err
 	}
 
 	dst.Values = make([][]byte, len(msg.Values))
 	for n, parameter := range msg.Values {
 		var err error
 		dst.Values[n], err = getValueFromJSON(parameter)
 		if err != nil {
 			return err
 		}
 	}
 	return nil
 }