package pgtype

import (

"database/sql"

"database/sql/driver"

"errors"

"fmt"

"net"

"net/netip"

"reflect"

"time"

)

// PostgreSQL oids for common types

const (

BoolOID = 16

ByteaOID = 17

QCharOID = 18

NameOID = 19

Int8OID = 20

Int2OID = 21

Int4OID = 23

TextOID = 25

OIDOID = 26

TIDOID = 27

XIDOID = 28

CIDOID = 29

JSONOID = 114

XMLOID = 142

XMLArrayOID = 143

JSONArrayOID = 199

XID8ArrayOID = 271

PointOID = 600

LsegOID = 601

PathOID = 602

BoxOID = 603

PolygonOID = 604

LineOID = 628

LineArrayOID = 629

CIDROID = 650

CIDRArrayOID = 651

Float4OID = 700

Float8OID = 701

CircleOID = 718

CircleArrayOID = 719

UnknownOID = 705

Macaddr8OID = 774

MacaddrOID = 829

InetOID = 869

BoolArrayOID = 1000

QCharArrayOID = 1002

NameArrayOID = 1003

Int2ArrayOID = 1005

Int4ArrayOID = 1007

TextArrayOID = 1009

TIDArrayOID = 1010

ByteaArrayOID = 1001

XIDArrayOID = 1011

CIDArrayOID = 1012

BPCharArrayOID = 1014

VarcharArrayOID = 1015

Int8ArrayOID = 1016

PointArrayOID = 1017

LsegArrayOID = 1018

PathArrayOID = 1019

BoxArrayOID = 1020

Float4ArrayOID = 1021

Float8ArrayOID = 1022

PolygonArrayOID = 1027

OIDArrayOID = 1028

ACLItemOID = 1033

ACLItemArrayOID = 1034

MacaddrArrayOID = 1040

InetArrayOID = 1041

BPCharOID = 1042

VarcharOID = 1043

DateOID = 1082

TimeOID = 1083

TimestampOID = 1114

TimestampArrayOID = 1115

DateArrayOID = 1182

TimeArrayOID = 1183

TimestamptzOID = 1184

TimestamptzArrayOID = 1185

IntervalOID = 1186

IntervalArrayOID = 1187

NumericArrayOID = 1231

TimetzOID = 1266

TimetzArrayOID = 1270

BitOID = 1560

BitArrayOID = 1561

VarbitOID = 1562

VarbitArrayOID = 1563

NumericOID = 1700

RecordOID = 2249

RecordArrayOID = 2287

UUIDOID = 2950

UUIDArrayOID = 2951

TSVectorOID = 3614

TSVectorArrayOID = 3643

JSONBOID = 3802

JSONBArrayOID = 3807

DaterangeOID = 3912

DaterangeArrayOID = 3913

Int4rangeOID = 3904

Int4rangeArrayOID = 3905

NumrangeOID = 3906

NumrangeArrayOID = 3907

TsrangeOID = 3908

TsrangeArrayOID = 3909

TstzrangeOID = 3910

TstzrangeArrayOID = 3911

Int8rangeOID = 3926

Int8rangeArrayOID = 3927

JSONPathOID = 4072

JSONPathArrayOID = 4073

Int4multirangeOID = 4451

NummultirangeOID = 4532

TsmultirangeOID = 4533

TstzmultirangeOID = 4534

DatemultirangeOID = 4535

Int8multirangeOID = 4536

XID8OID = 5069

Int4multirangeArrayOID = 6150

NummultirangeArrayOID = 6151

TsmultirangeArrayOID = 6152

TstzmultirangeArrayOID = 6153

DatemultirangeArrayOID = 6155

Int8multirangeArrayOID = 6157

)

type InfinityModifier int8

const (

Infinity InfinityModifier = 1

Finite InfinityModifier = 0

NegativeInfinity InfinityModifier = -Infinity

)

func (im InfinityModifier) String() string {

switch im {

case Finite:

return "finite"

case Infinity:

return "infinity"

case NegativeInfinity:

return "-infinity"

default:

return "invalid"

}

}

// PostgreSQL format codes

const (

TextFormatCode = 0

BinaryFormatCode = 1

)

// A Codec converts between Go and PostgreSQL values. A Codec must not be mutated after it is registered with a [Map].

type Codec interface {

// FormatSupported returns true if the format is supported.

FormatSupported(int16) bool

// PreferredFormat returns the preferred format.

PreferredFormat() int16

// PlanEncode returns an EncodePlan for encoding value into PostgreSQL format for oid and format. If no plan can be

// found then nil is returned.

PlanEncode(m *Map, oid uint32, format int16, value any) EncodePlan

// PlanScan returns a ScanPlan for scanning a PostgreSQL value into a destination with the same type as target. If

// no plan can be found then nil is returned.

PlanScan(m *Map, oid uint32, format int16, target any) ScanPlan

// DecodeDatabaseSQLValue returns src decoded into a value compatible with the sql.Scanner interface.

DecodeDatabaseSQLValue(m *Map, oid uint32, format int16, src []byte) (driver.Value, error)

// DecodeValue returns src decoded into its default format.

DecodeValue(m *Map, oid uint32, format int16, src []byte) (any, error)

}

type nullAssignmentError struct {

dst any

}

func (e *nullAssignmentError) Error() string {

return fmt.Sprintf("cannot assign NULL to %T", e.dst)

}

// Type represents a PostgreSQL data type. It must not be mutated after it is registered with a [Map].

type Type struct {

Codec Codec

Name string

OID uint32

}

// Map is the mapping between PostgreSQL server types and Go type handling logic. It can encode values for

// transmission to a PostgreSQL server and scan received values.

type Map struct {

oidToType map[uint32]*Type

nameToType map[string]*Type

reflectTypeToName map[reflect.Type]string

oidToFormatCode map[uint32]int16

reflectTypeToType map[reflect.Type]*Type

memoizedEncodePlans map[uint32]map[reflect.Type][2]EncodePlan

// TryWrapEncodePlanFuncs is a slice of functions that will wrap a value that cannot be encoded by the Codec. Every

// time a wrapper is found the PlanEncode method will be recursively called with the new value. This allows several layers of wrappers

// to be built up. There are default functions placed in this slice by NewMap(). In most cases these functions

// should run last. i.e. Additional functions should typically be prepended not appended.

TryWrapEncodePlanFuncs []TryWrapEncodePlanFunc

// TryWrapScanPlanFuncs is a slice of functions that will wrap a target that cannot be scanned into by the Codec. Every

// time a wrapper is found the PlanScan method will be recursively called with the new target. This allows several layers of wrappers

// to be built up. There are default functions placed in this slice by NewMap(). In most cases these functions

// should run last. i.e. Additional functions should typically be prepended not appended.

TryWrapScanPlanFuncs []TryWrapScanPlanFunc

}

// Copy returns a new Map containing the same registered types.

func (m *Map) Copy() *Map {

newMap := NewMap()

for _, type_ := range m.oidToType {

newMap.RegisterType(type_)

}

return newMap

}

func NewMap() *Map {

defaultMapInitOnce.Do(initDefaultMap)

return &Map{

oidToType: make(map[uint32]*Type),

nameToType: make(map[string]*Type),

reflectTypeToName: make(map[reflect.Type]string),

oidToFormatCode: make(map[uint32]int16),

memoizedEncodePlans: make(map[uint32]map[reflect.Type][2]EncodePlan),

TryWrapEncodePlanFuncs: []TryWrapEncodePlanFunc{

TryWrapDerefPointerEncodePlan,

TryWrapBuiltinTypeEncodePlan,

TryWrapFindUnderlyingTypeEncodePlan,

TryWrapStringerEncodePlan,

TryWrapStructEncodePlan,

TryWrapSliceEncodePlan,

TryWrapMultiDimSliceEncodePlan,

TryWrapArrayEncodePlan,

},

TryWrapScanPlanFuncs: []TryWrapScanPlanFunc{

TryPointerPointerScanPlan,

TryWrapBuiltinTypeScanPlan,

TryFindUnderlyingTypeScanPlan,

TryWrapStructScanPlan,

TryWrapPtrSliceScanPlan,

TryWrapPtrMultiDimSliceScanPlan,

TryWrapPtrArrayScanPlan,

},

}

}

// RegisterTypes registers multiple data types in the sequence they are provided.

func (m *Map) RegisterTypes(types []*Type) {

for _, t := range types {

m.RegisterType(t)

}

}

// RegisterType registers a data type with the [Map]. t must not be mutated after it is registered.

func (m *Map) RegisterType(t *Type) {

m.oidToType[t.OID] = t

m.nameToType[t.Name] = t

m.oidToFormatCode[t.OID] = t.Codec.PreferredFormat()

// Invalidated by type registration

m.reflectTypeToType = nil

for k := range m.memoizedEncodePlans {

delete(m.memoizedEncodePlans, k)

}

}

// RegisterDefaultPgType registers a mapping of a Go type to a PostgreSQL type name. Typically the data type to be

// encoded or decoded is determined by the PostgreSQL OID. But if the OID of a value to be encoded or decoded is

// unknown, this additional mapping will be used by TypeForValue to determine a suitable data type.

func (m *Map) RegisterDefaultPgType(value any, name string) {

m.reflectTypeToName[reflect.TypeOf(value)] = name

// Invalidated by type registration

m.reflectTypeToType = nil

for k := range m.memoizedEncodePlans {

delete(m.memoizedEncodePlans, k)

}

}

// TypeForOID returns the [Type] registered for the given OID. The returned [Type] must not be mutated.

func (m *Map) TypeForOID(oid uint32) (*Type, bool) {

if dt, ok := m.oidToType[oid]; ok {

return dt, true

}

dt, ok := defaultMap.oidToType[oid]

return dt, ok

}

// TypeForName returns the [Type] registered for the given name. The returned [Type] must not be mutated.

func (m *Map) TypeForName(name string) (*Type, bool) {

if dt, ok := m.nameToType[name]; ok {

return dt, true

}

dt, ok := defaultMap.nameToType[name]

return dt, ok

}

func (m *Map) buildReflectTypeToType() {

m.reflectTypeToType = make(map[reflect.Type]*Type)

for reflectType, name := range m.reflectTypeToName {

if dt, ok := m.TypeForName(name); ok {

m.reflectTypeToType[reflectType] = dt

}

}

}

// TypeForValue finds a data type suitable for v. Use [Map.RegisterType] to register types that can encode and decode

// themselves. Use [Map.RegisterDefaultPgType] to register that can be handled by a registered data type. The returned [Type]

// must not be mutated.

func (m *Map) TypeForValue(v any) (*Type, bool) {

if m.reflectTypeToType == nil {

m.buildReflectTypeToType()

}

if dt, ok := m.reflectTypeToType[reflect.TypeOf(v)]; ok {

return dt, true

}

dt, ok := defaultMap.reflectTypeToType[reflect.TypeOf(v)]

return dt, ok

}

// FormatCodeForOID returns the preferred format code for type oid. If the type is not registered it returns the text

// format code.

func (m *Map) FormatCodeForOID(oid uint32) int16 {

if fc, ok := m.oidToFormatCode[oid]; ok {

return fc

}

if fc, ok := defaultMap.oidToFormatCode[oid]; ok {

return fc

}

return TextFormatCode

}

// EncodePlan is a precompiled plan to encode a particular type into a particular OID and format.

type EncodePlan interface {

// Encode appends the encoded bytes of value to buf. If value is the SQL value NULL then append nothing and return

// (nil, nil). The caller of Encode is responsible for writing the correct NULL value or the length of the data

// written.

Encode(value any, buf []byte) (newBuf []byte, err error)

}

// ScanPlan is a precompiled plan to scan into a type of destination.

type ScanPlan interface {

// Scan scans src into target. src is only valid during the call to Scan. The ScanPlan must not retain a reference to

// src.

Scan(src []byte, target any) error

}

type scanPlanCodecSQLScanner struct {

c Codec

m *Map

oid uint32

formatCode int16

}

func (plan *scanPlanCodecSQLScanner) Scan(src []byte, dst any) error {

value, err := plan.c.DecodeDatabaseSQLValue(plan.m, plan.oid, plan.formatCode, src)

if err != nil {

return err

}

scanner := dst.(sql.Scanner)

return scanner.Scan(value)

}

type scanPlanSQLScanner struct {

formatCode int16

}

func (plan *scanPlanSQLScanner) Scan(src []byte, dst any) error {

scanner := dst.(sql.Scanner)

if src == nil {

// This is necessary because interface value []byte:nil does not equal nil:nil for the binary format path and the

// text format path would be converted to empty string.

return scanner.Scan(nil)

} else if plan.formatCode == BinaryFormatCode {

return scanner.Scan(src)

} else {

return scanner.Scan(string(src))

}

}

type scanPlanString struct{}

func (scanPlanString) Scan(src []byte, dst any) error {

if src == nil {

return fmt.Errorf("cannot scan NULL into %T", dst)

}

p := (dst).(*string)

*p = string(src)

return nil

}

type scanPlanAnyTextToBytes struct{}

func (scanPlanAnyTextToBytes) Scan(src []byte, dst any) error {

dstBuf := dst.(*[]byte)

if src == nil {

*dstBuf = nil

return nil

}

*dstBuf = make([]byte, len(src))

copy(*dstBuf, src)

return nil

}

type scanPlanFail struct {

m *Map

oid uint32

formatCode int16

}

func (plan *scanPlanFail) Scan(src []byte, dst any) error {

// If src is NULL it might be possible to scan into dst even though it is the types are not compatible. While this

// may seem to be a contrived case it can occur when selecting NULL directly. PostgreSQL assigns it the type of text.

// It would be surprising to the caller to have to cast the NULL (e.g. `select null::int`). So try to figure out a

// compatible data type for dst and scan with that.

//

// See https://github.com/jackc/pgx/issues/1326

if src == nil {

// As a horrible hack try all types to find anything that can scan into dst.

for oid := range plan.m.oidToType {

// using planScan instead of Scan or PlanScan to avoid polluting the planned scan cache.

plan := plan.m.planScan(oid, plan.formatCode, dst, 0)

if _, ok := plan.(*scanPlanFail); !ok {

return plan.Scan(src, dst)

}

}

for oid := range defaultMap.oidToType {

if _, ok := plan.m.oidToType[oid]; !ok {

plan := plan.m.planScan(oid, plan.formatCode, dst, 0)

if _, ok := plan.(*scanPlanFail); !ok {

return plan.Scan(src, dst)

}

}

}

}

var format string

switch plan.formatCode {

case TextFormatCode:

format = "text"

case BinaryFormatCode:

format = "binary"

default:

format = fmt.Sprintf("unknown %d", plan.formatCode)

}

var dataTypeName string

if t, ok := plan.m.TypeForOID(plan.oid); ok {

dataTypeName = t.Name

} else {

dataTypeName = "unknown type"

}

return fmt.Errorf("cannot scan %s (OID %d) in %v format into %T", dataTypeName, plan.oid, format, dst)

}

// TryWrapScanPlanFunc is a function that tries to create a wrapper plan for target. If successful it returns a plan

// that will convert the target passed to Scan and then call the next plan. nextTarget is target as it will be converted

// by plan. It must be used to find another suitable ScanPlan. When it is found SetNext must be called on plan for it

// to be usabled. ok indicates if a suitable wrapper was found.

type TryWrapScanPlanFunc func(target any) (plan WrappedScanPlanNextSetter, nextTarget any, ok bool)

type pointerPointerScanPlan struct {

dstType reflect.Type

next ScanPlan

}

func (plan *pointerPointerScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *pointerPointerScanPlan) Scan(src []byte, dst any) error {

el := reflect.ValueOf(dst).Elem()

if src == nil {

el.Set(reflect.Zero(el.Type()))

return nil

}

el.Set(reflect.New(el.Type().Elem()))

return plan.next.Scan(src, el.Interface())

}

// TryPointerPointerScanPlan handles a pointer to a pointer by setting the target to nil for SQL NULL and allocating and

// scanning for non-NULL.

func TryPointerPointerScanPlan(target any) (plan WrappedScanPlanNextSetter, nextTarget any, ok bool) {

if dstValue := reflect.ValueOf(target); dstValue.Kind() == reflect.Ptr {

elemValue := dstValue.Elem()

if elemValue.Kind() == reflect.Ptr {

plan = &pointerPointerScanPlan{dstType: dstValue.Type()}

return plan, reflect.Zero(elemValue.Type()).Interface(), true

}

}

return nil, nil, false

}

// SkipUnderlyingTypePlanner prevents PlanScan and PlanDecode from trying to use the underlying type.

type SkipUnderlyingTypePlanner interface {

SkipUnderlyingTypePlan()

}

var elemKindToPointerTypes map[reflect.Kind]reflect.Type = map[reflect.Kind]reflect.Type{

reflect.Int: reflect.TypeFor[*int](),

reflect.Int8: reflect.TypeFor[*int8](),

reflect.Int16: reflect.TypeFor[*int16](),

reflect.Int32: reflect.TypeFor[*int32](),

reflect.Int64: reflect.TypeFor[*int64](),

reflect.Uint: reflect.TypeFor[*uint](),

reflect.Uint8: reflect.TypeFor[*uint8](),

reflect.Uint16: reflect.TypeFor[*uint16](),

reflect.Uint32: reflect.TypeFor[*uint32](),

reflect.Uint64: reflect.TypeFor[*uint64](),

reflect.Float32: reflect.TypeFor[*float32](),

reflect.Float64: reflect.TypeFor[*float64](),

reflect.String: reflect.TypeFor[*string](),

reflect.Bool: reflect.TypeFor[*bool](),

}

type underlyingTypeScanPlan struct {

dstType reflect.Type

nextDstType reflect.Type

next ScanPlan

}

func (plan *underlyingTypeScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *underlyingTypeScanPlan) Scan(src []byte, dst any) error {

return plan.next.Scan(src, reflect.ValueOf(dst).Convert(plan.nextDstType).Interface())

}

// TryFindUnderlyingTypeScanPlan tries to convert to a Go builtin type. e.g. If value was of type MyString and

// MyString was defined as a string then a wrapper plan would be returned that converts MyString to string.

func TryFindUnderlyingTypeScanPlan(dst any) (plan WrappedScanPlanNextSetter, nextDst any, ok bool) {

if _, ok := dst.(SkipUnderlyingTypePlanner); ok {

return nil, nil, false

}

dstValue := reflect.ValueOf(dst)

if dstValue.Kind() == reflect.Ptr {

var elemValue reflect.Value

if dstValue.IsNil() {

elemValue = reflect.New(dstValue.Type().Elem()).Elem()

} else {

elemValue = dstValue.Elem()

}

nextDstType := elemKindToPointerTypes[elemValue.Kind()]

if nextDstType == nil {

if elemValue.Kind() == reflect.Slice {

if elemValue.Type().Elem().Kind() == reflect.Uint8 {

var v *[]byte

nextDstType = reflect.TypeOf(v)

}

}

// Get underlying type of any array.

// https://github.com/jackc/pgx/issues/2107

if elemValue.Kind() == reflect.Array {

nextDstType = reflect.PointerTo(reflect.ArrayOf(elemValue.Len(), elemValue.Type().Elem()))

}

}

if nextDstType != nil && dstValue.Type() != nextDstType && dstValue.CanConvert(nextDstType) {

return &underlyingTypeScanPlan{dstType: dstValue.Type(), nextDstType: nextDstType}, dstValue.Convert(nextDstType).Interface(), true

}

}

return nil, nil, false

}

type WrappedScanPlanNextSetter interface {

SetNext(ScanPlan)

ScanPlan

}

// TryWrapBuiltinTypeScanPlan tries to wrap a builtin type with a wrapper that provides additional methods. e.g. If

// value was of type int32 then a wrapper plan would be returned that converts target to a value that implements

// Int64Scanner.

func TryWrapBuiltinTypeScanPlan(target any) (plan WrappedScanPlanNextSetter, nextDst any, ok bool) {

switch target := target.(type) {

case *int8:

return &wrapInt8ScanPlan{}, (*int8Wrapper)(target), true

case *int16:

return &wrapInt16ScanPlan{}, (*int16Wrapper)(target), true

case *int32:

return &wrapInt32ScanPlan{}, (*int32Wrapper)(target), true

case *int64:

return &wrapInt64ScanPlan{}, (*int64Wrapper)(target), true

case *int:

return &wrapIntScanPlan{}, (*intWrapper)(target), true

case *uint8:

return &wrapUint8ScanPlan{}, (*uint8Wrapper)(target), true

case *uint16:

return &wrapUint16ScanPlan{}, (*uint16Wrapper)(target), true

case *uint32:

return &wrapUint32ScanPlan{}, (*uint32Wrapper)(target), true

case *uint64:

return &wrapUint64ScanPlan{}, (*uint64Wrapper)(target), true

case *uint:

return &wrapUintScanPlan{}, (*uintWrapper)(target), true

case *float32:

return &wrapFloat32ScanPlan{}, (*float32Wrapper)(target), true

case *float64:

return &wrapFloat64ScanPlan{}, (*float64Wrapper)(target), true

case *string:

return &wrapStringScanPlan{}, (*stringWrapper)(target), true

case *time.Time:

return &wrapTimeScanPlan{}, (*timeWrapper)(target), true

case *time.Duration:

return &wrapDurationScanPlan{}, (*durationWrapper)(target), true

case *net.IPNet:

return &wrapNetIPNetScanPlan{}, (*netIPNetWrapper)(target), true

case *net.IP:

return &wrapNetIPScanPlan{}, (*netIPWrapper)(target), true

case *netip.Prefix:

return &wrapNetipPrefixScanPlan{}, (*netipPrefixWrapper)(target), true

case *netip.Addr:

return &wrapNetipAddrScanPlan{}, (*netipAddrWrapper)(target), true

case *map[string]*string:

return &wrapMapStringToPointerStringScanPlan{}, (*mapStringToPointerStringWrapper)(target), true

case *map[string]string:

return &wrapMapStringToStringScanPlan{}, (*mapStringToStringWrapper)(target), true

case *[16]byte:

return &wrapByte16ScanPlan{}, (*byte16Wrapper)(target), true

case *[]byte:

return &wrapByteSliceScanPlan{}, (*byteSliceWrapper)(target), true

}

return nil, nil, false

}

type wrapInt8ScanPlan struct {

next ScanPlan

}

func (plan *wrapInt8ScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapInt8ScanPlan) Scan(src []byte, dst any) error {

return plan.next.Scan(src, (*int8Wrapper)(dst.(*int8)))

}

type wrapInt16ScanPlan struct {

next ScanPlan

}

func (plan *wrapInt16ScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapInt16ScanPlan) Scan(src []byte, dst any) error {

return plan.next.Scan(src, (*int16Wrapper)(dst.(*int16)))

}

type wrapInt32ScanPlan struct {

next ScanPlan

}

func (plan *wrapInt32ScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapInt32ScanPlan) Scan(src []byte, dst any) error {

return plan.next.Scan(src, (*int32Wrapper)(dst.(*int32)))

}

type wrapInt64ScanPlan struct {

next ScanPlan

}

func (plan *wrapInt64ScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapInt64ScanPlan) Scan(src []byte, dst any) error {

return plan.next.Scan(src, (*int64Wrapper)(dst.(*int64)))

}

type wrapIntScanPlan struct {

next ScanPlan

}

func (plan *wrapIntScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapIntScanPlan) Scan(src []byte, dst any) error {

return plan.next.Scan(src, (*intWrapper)(dst.(*int)))

}

type wrapUint8ScanPlan struct {

next ScanPlan

}

func (plan *wrapUint8ScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapUint8ScanPlan) Scan(src []byte, dst any) error {

return plan.next.Scan(src, (*uint8Wrapper)(dst.(*uint8)))

}

type wrapUint16ScanPlan struct {

next ScanPlan

}

func (plan *wrapUint16ScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapUint16ScanPlan) Scan(src []byte, dst any) error {

return plan.next.Scan(src, (*uint16Wrapper)(dst.(*uint16)))

}

type wrapUint32ScanPlan struct {

next ScanPlan

}

func (plan *wrapUint32ScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapUint32ScanPlan) Scan(src []byte, dst any) error {

return plan.next.Scan(src, (*uint32Wrapper)(dst.(*uint32)))

}

type wrapUint64ScanPlan struct {

next ScanPlan

}

func (plan *wrapUint64ScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapUint64ScanPlan) Scan(src []byte, dst any) error {

return plan.next.Scan(src, (*uint64Wrapper)(dst.(*uint64)))

}

type wrapUintScanPlan struct {

next ScanPlan

}

func (plan *wrapUintScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapUintScanPlan) Scan(src []byte, dst any) error {

return plan.next.Scan(src, (*uintWrapper)(dst.(*uint)))

}

type wrapFloat32ScanPlan struct {

next ScanPlan

}

func (plan *wrapFloat32ScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapFloat32ScanPlan) Scan(src []byte, dst any) error {

return plan.next.Scan(src, (*float32Wrapper)(dst.(*float32)))

}

type wrapFloat64ScanPlan struct {

next ScanPlan

}

func (plan *wrapFloat64ScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapFloat64ScanPlan) Scan(src []byte, dst any) error {

return plan.next.Scan(src, (*float64Wrapper)(dst.(*float64)))

}

type wrapStringScanPlan struct {

next ScanPlan

}

func (plan *wrapStringScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapStringScanPlan) Scan(src []byte, dst any) error {

return plan.next.Scan(src, (*stringWrapper)(dst.(*string)))

}

type wrapTimeScanPlan struct {

next ScanPlan

}

func (plan *wrapTimeScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapTimeScanPlan) Scan(src []byte, dst any) error {

return plan.next.Scan(src, (*timeWrapper)(dst.(*time.Time)))

}

type wrapDurationScanPlan struct {

next ScanPlan

}

func (plan *wrapDurationScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapDurationScanPlan) Scan(src []byte, dst any) error {

return plan.next.Scan(src, (*durationWrapper)(dst.(*time.Duration)))

}

type wrapNetIPNetScanPlan struct {

next ScanPlan

}

func (plan *wrapNetIPNetScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapNetIPNetScanPlan) Scan(src []byte, dst any) error {

return plan.next.Scan(src, (*netIPNetWrapper)(dst.(*net.IPNet)))

}

type wrapNetIPScanPlan struct {

next ScanPlan

}

func (plan *wrapNetIPScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapNetIPScanPlan) Scan(src []byte, dst any) error {

return plan.next.Scan(src, (*netIPWrapper)(dst.(*net.IP)))

}

type wrapNetipPrefixScanPlan struct {

next ScanPlan

}

func (plan *wrapNetipPrefixScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapNetipPrefixScanPlan) Scan(src []byte, dst any) error {

return plan.next.Scan(src, (*netipPrefixWrapper)(dst.(*netip.Prefix)))

}

type wrapNetipAddrScanPlan struct {

next ScanPlan

}

func (plan *wrapNetipAddrScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapNetipAddrScanPlan) Scan(src []byte, dst any) error {

return plan.next.Scan(src, (*netipAddrWrapper)(dst.(*netip.Addr)))

}

type wrapMapStringToPointerStringScanPlan struct {

next ScanPlan

}

func (plan *wrapMapStringToPointerStringScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapMapStringToPointerStringScanPlan) Scan(src []byte, dst any) error {

return plan.next.Scan(src, (*mapStringToPointerStringWrapper)(dst.(*map[string]*string)))

}

type wrapMapStringToStringScanPlan struct {

next ScanPlan

}

func (plan *wrapMapStringToStringScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapMapStringToStringScanPlan) Scan(src []byte, dst any) error {

return plan.next.Scan(src, (*mapStringToStringWrapper)(dst.(*map[string]string)))

}

type wrapByte16ScanPlan struct {

next ScanPlan

}

func (plan *wrapByte16ScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapByte16ScanPlan) Scan(src []byte, dst any) error {

return plan.next.Scan(src, (*byte16Wrapper)(dst.(*[16]byte)))

}

type wrapByteSliceScanPlan struct {

next ScanPlan

}

func (plan *wrapByteSliceScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapByteSliceScanPlan) Scan(src []byte, dst any) error {

return plan.next.Scan(src, (*byteSliceWrapper)(dst.(*[]byte)))

}

type pointerEmptyInterfaceScanPlan struct {

codec Codec

m *Map

oid uint32

formatCode int16

}

func (plan *pointerEmptyInterfaceScanPlan) Scan(src []byte, dst any) error {

value, err := plan.codec.DecodeValue(plan.m, plan.oid, plan.formatCode, src)

if err != nil {

return err

}

ptrAny := dst.(*any)

*ptrAny = value

return nil

}

// TryWrapStructScanPlan tries to wrap a struct with a wrapper that implements CompositeIndexGetter.

func TryWrapStructScanPlan(target any) (plan WrappedScanPlanNextSetter, nextValue any, ok bool) {

targetValue := reflect.ValueOf(target)

if targetValue.Kind() != reflect.Ptr {

return nil, nil, false

}

var targetElemValue reflect.Value

if targetValue.IsNil() {

targetElemValue = reflect.Zero(targetValue.Type().Elem())

} else {

targetElemValue = targetValue.Elem()

}

targetElemType := targetElemValue.Type()

if targetElemType.Kind() == reflect.Struct {

exportedFields := getExportedFieldValues(targetElemValue)

if len(exportedFields) == 0 {

return nil, nil, false

}

w := ptrStructWrapper{

s: target,

exportedFields: exportedFields,

}

return &wrapAnyPtrStructScanPlan{}, &w, true

}

return nil, nil, false

}

type wrapAnyPtrStructScanPlan struct {

next ScanPlan

}

func (plan *wrapAnyPtrStructScanPlan) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapAnyPtrStructScanPlan) Scan(src []byte, target any) error {

w := ptrStructWrapper{

s: target,

exportedFields: getExportedFieldValues(reflect.ValueOf(target).Elem()),

}

return plan.next.Scan(src, &w)

}

// TryWrapPtrSliceScanPlan tries to wrap a pointer to a single dimension slice.

func TryWrapPtrSliceScanPlan(target any) (plan WrappedScanPlanNextSetter, nextValue any, ok bool) {

// Avoid using reflect path for common types.

switch target := target.(type) {

case *[]int16:

return &wrapPtrSliceScanPlan[int16]{}, (*FlatArray[int16])(target), true

case *[]int32:

return &wrapPtrSliceScanPlan[int32]{}, (*FlatArray[int32])(target), true

case *[]int64:

return &wrapPtrSliceScanPlan[int64]{}, (*FlatArray[int64])(target), true

case *[]float32:

return &wrapPtrSliceScanPlan[float32]{}, (*FlatArray[float32])(target), true

case *[]float64:

return &wrapPtrSliceScanPlan[float64]{}, (*FlatArray[float64])(target), true

case *[]string:

return &wrapPtrSliceScanPlan[string]{}, (*FlatArray[string])(target), true

case *[]time.Time:

return &wrapPtrSliceScanPlan[time.Time]{}, (*FlatArray[time.Time])(target), true

}

targetType := reflect.TypeOf(target)

if targetType.Kind() != reflect.Ptr {

return nil, nil, false

}

targetElemType := targetType.Elem()

if targetElemType.Kind() == reflect.Slice {

slice := reflect.New(targetElemType).Elem()

return &wrapPtrSliceReflectScanPlan{}, &anySliceArrayReflect{slice: slice}, true

}

return nil, nil, false

}

type wrapPtrSliceScanPlan[T any] struct {

next ScanPlan

}

func (plan *wrapPtrSliceScanPlan[T]) SetNext(next ScanPlan) { plan.next = next }

func (plan *wrapPtrSliceScanPlan[T]) Scan(src []byte, target any) error {

return plan.next.Scan(src, (*FlatArray[T])(target.(*[]T)))

}

type wrapPtrSliceReflectScanPlan struct {

next ScanPlan

}