mirror of https://github.com/jackc/pgx.git
110 lines
2.6 KiB
Go
110 lines
2.6 KiB
Go
package pgtype_test
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
|
|
"github.com/jackc/pgtype"
|
|
pgx "github.com/jackc/pgx/v4"
|
|
errors "golang.org/x/xerrors"
|
|
)
|
|
|
|
type MyType struct {
|
|
a int32 // NULL will cause decoding error
|
|
b *string // there can be NULL in this position in SQL
|
|
}
|
|
|
|
func (dst *MyType) DecodeBinary(ci *pgtype.ConnInfo, src []byte) error {
|
|
if src == nil {
|
|
return errors.New("NULL values can't be decoded. Scan into a &*MyType to handle NULLs")
|
|
}
|
|
|
|
a := pgtype.Int4{}
|
|
b := pgtype.Text{}
|
|
|
|
if err := pgtype.ScanRowValue(ci, src, &a, &b); err != nil {
|
|
return err
|
|
}
|
|
|
|
// type compatibility is checked by AssignTo
|
|
// only lossless assignments will succeed
|
|
if err := a.AssignTo(&dst.a); err != nil {
|
|
return err
|
|
}
|
|
|
|
// AssignTo also deals with null value handling
|
|
if err := b.AssignTo(&dst.b); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (src MyType) EncodeBinary(ci *pgtype.ConnInfo, buf []byte) (newBuf []byte, err error) {
|
|
a := pgtype.Int4{src.a, pgtype.Present}
|
|
var b pgtype.Text
|
|
if src.b != nil {
|
|
b = pgtype.Text{*src.b, pgtype.Present}
|
|
} else {
|
|
b = pgtype.Text{Status: pgtype.Null}
|
|
}
|
|
|
|
return pgtype.EncodeRow(ci, buf, &a, &b)
|
|
}
|
|
|
|
func ptrS(s string) *string {
|
|
return &s
|
|
}
|
|
|
|
func E(err error) {
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
|
|
func Example_compositeTypes() {
|
|
conn, err := pgx.Connect(context.Background(), os.Getenv("PGX_TEST_DATABASE"))
|
|
E(err)
|
|
|
|
defer conn.Close(context.Background())
|
|
_, err = conn.Exec(context.Background(), `drop type if exists mytype;
|
|
|
|
create type mytype as (
|
|
a int4,
|
|
b text
|
|
);`)
|
|
E(err)
|
|
defer conn.Exec(context.Background(), "drop type mytype")
|
|
|
|
var result *MyType
|
|
|
|
// Demonstrates both passing and reading back composite values
|
|
err = conn.QueryRow(context.Background(), "select $1::mytype",
|
|
pgx.QueryResultFormats{pgx.BinaryFormatCode}, MyType{1, ptrS("foo")}).Scan(&result)
|
|
E(err)
|
|
|
|
fmt.Printf("First row: a=%d b=%s\n", result.a, *result.b)
|
|
|
|
// Because we scan into &*MyType, NULLs are handled generically by assigning nil to result
|
|
err = conn.QueryRow(context.Background(), "select NULL::mytype", pgx.QueryResultFormats{pgx.BinaryFormatCode}).Scan(&result)
|
|
E(err)
|
|
|
|
fmt.Printf("Second row: %v\n", result)
|
|
|
|
// Adhoc rows can be decoded inplace without boilerplate (works with composite types too)
|
|
var isNull bool
|
|
var a int
|
|
var b *string
|
|
|
|
err = conn.QueryRow(context.Background(), "select (2, 'bar')::mytype", pgx.QueryResultFormats{pgx.BinaryFormatCode}).Scan(pgtype.ROW(&isNull, &a, &b))
|
|
E(err)
|
|
|
|
fmt.Printf("Adhoc: isNull=%v a=%d b=%s", isNull, a, *b)
|
|
|
|
// Output:
|
|
// First row: a=1 b=foo
|
|
// Second row: <nil>
|
|
// Adhoc: isNull=false a=2 b=bar
|
|
}
|