All known and nullable types support

Author: alienvspredator

main.go

@@ -3,6 +3,7 @@ package main
 import (
 	"context"
 	"encoding/binary"
+	"errors"
 	"flag"
 	"fmt"
 	"os"
@@ -14,9 +15,11 @@ import (
 )
 
 var (
-	connStr       string
-	selGenericSQL string
-	reqFlags      = []string{"dsn", "sql"}
+	connStr           string
+	selGenericSQL     string
+	reqFlags          = []string{"dsn", "sql"}
+	ci                = pgtype.NewConnInfo()
+	errUnsupportedOID = errors.New("unsupported OID")
 )
 
 func init() {
@@ -54,6 +57,43 @@ func checkFlags() error {
 	return nil
 }
 
+// getRaw returns a raw bytes of value and a new type start.
+func getRaw(bytes []byte, start, len uint32) ([]byte, uint32) {
+	if len == 0xFFFFFFFF {
+		len = 0
+	}
+
+	return bytes[start+8 : start+8+len], start + len + 8
+}
+
+// scanRaw returns the value and a name of the type.
+func scanRaw(oid uint32, bytes []byte, len uint32) (value interface{}, name string, err error) {
+	dt, ok := ci.DataTypeForOID(oid)
+	if !ok {
+		return nil, "", errUnsupportedOID
+	}
+	name = dt.Name
+
+	if len == 0xFFFFFFFF {
+		value = "(NULL)"
+	} else {
+		if bd, ok := dt.Value.(pgtype.BinaryDecoder); ok {
+			if err := bd.DecodeBinary(ci, bytes); err != nil {
+				return nil, "", err
+			}
+		} else {
+			return nil, "", fmt.Errorf("%T is not binary pgtype.BinaryDecoder", dt.Value)
+		}
+
+		value = dt.Value.Get()
+		if value == "(NULL)" {
+			value = `"(NULL)"`
+		}
+	}
+
+	return
+}
+
 func main() {
 	flag.Parse()
 	if err := checkFlags(); err != nil {
@@ -69,6 +109,16 @@ func main() {
 	}
 	defer pool.Close()
 
+	genericText := &pgtype.GenericText{}
+	if err := pool.QueryRow(
+		ctx,
+		selGenericSQL,
+		pgx.QueryResultFormats{pgx.TextFormatCode},
+	).Scan(genericText); err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+
 	genericBinary := &pgtype.GenericBinary{}
 	if err := pool.QueryRow(
 		ctx,
@@ -79,6 +129,7 @@ func main() {
 		os.Exit(1)
 	}
 
+	fmt.Printf("Text: %v\n", genericText.String)
 	fmt.Printf("Binary: %v\n", genericBinary.Bytes)
 
 	rawNumOfFields := genericBinary.Bytes[:4]
@@ -88,73 +139,45 @@ func main() {
 		rawNumOfFields,
 		numOfFieldsUint32,
 	)
-	ci := pgtype.NewConnInfo()
 
 	// The first 4 bytes are the number of fields - 2
 	// Then for each field:
 	// 4 bytes - OID
 	// 4 bytes - length of value
 	// x bytes - value
-	typeStart := 4
+	typeStart := uint32(4)
 	for i := uint32(0); i < numOfFieldsUint32; i++ {
 		rawOID := genericBinary.Bytes[typeStart : typeStart+4]
 		oid := binary.BigEndian.Uint32(rawOID)
+
 		rawValLen := genericBinary.Bytes[typeStart+4 : typeStart+8]
 		valLen := binary.BigEndian.Uint32(rawValLen)
-		rawVal := genericBinary.Bytes[typeStart+8 : typeStart+8+int(valLen)]
-		typeStart += int(valLen) + 8
-
-		var scanned interface{}
-		var typeName string
-
-		switch oid {
-		case pgtype.Int4OID:
-			typeName = "int4 (int32)"
-			var dst int32
-			if err := ci.Scan(oid, pgtype.BinaryFormatCode, rawVal, &dst); err != nil {
-				fmt.Println(err)
-				os.Exit(1)
-			}
-
-			scanned = dst
-
-		case pgtype.Float8OID:
-			typeName = "float8 (double)"
-			var dst float64
-			if err := ci.Scan(oid, pgtype.BinaryFormatCode, rawVal, &dst); err != nil {
-				fmt.Println(err)
-				os.Exit(1)
-			}
 
-			scanned = dst
+		var rawVal []byte
+		rawVal, typeStart = getRaw(genericBinary.Bytes, typeStart, valLen)
 
-		case pgtype.TextOID:
-			typeName = "text"
-			var dst string
-			if err := ci.Scan(oid, pgtype.BinaryFormatCode, rawVal, &dst); err != nil {
+		value, typeName, err := scanRaw(oid, rawVal, valLen)
+		if err != nil {
+			if !errors.Is(err, errUnsupportedOID) {
 				fmt.Println(err)
 				os.Exit(1)
 			}
 
-			scanned = dst
-
-		default:
-			typeName = "Unsupported"
-			scanned = "Unsupported"
+			value, typeName = "Unsupported", "Unsupported"
 		}
 
 		fmt.Printf(
 			`Field %d:
-	OID: %d
+	OID: %d (%v)
 	Type %s
-	Length: %d
-	Value: %v
+	Length: %d (%v)
+	Value: %v (%v)
 `,
 			i,
-			oid,
+			oid, rawOID,
 			typeName,
-			valLen,
-			scanned,
+			valLen, rawValLen,
+			value, rawVal,
 		)
 	}