GOMODULES
/
pgx
mirror of https://github.com/jackc/pgx.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Use Go casing convention for CID/TID/XID/CIDR

non-blocking
Jack Christensen 2017-06-03 12:01:49 -05:00
parent 01fa5960b2
commit 654adbdd4a
15 changed files with 209 additions and 209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
cid.go
View File

@ -4,7 +4,7 @@ import (
"database/sql/driver"
)
// Cid is PostgreSQL's Command Identifier type.
// CID is PostgreSQL's Command Identifier type.
//
// When one does
//
@ -15,47 +15,47 @@ import (
// It is currently implemented as an unsigned four byte integer.
// Its definition can be found in src/include/c.h as CommandId
// in the PostgreSQL sources.
type Cid pguint32
type CID pguint32
// Set converts from src to dst. Note that as Cid is not a general
// Set converts from src to dst. Note that as CID is not a general
// number type Set does not do automatic type conversion as other number
// types do.
func (dst *Cid) Set(src interface{}) error {
func (dst *CID) Set(src interface{}) error {
return (*pguint32)(dst).Set(src)
}
func (dst *Cid) Get() interface{} {
func (dst *CID) Get() interface{} {
return (*pguint32)(dst).Get()
}
// AssignTo assigns from src to dst. Note that as Cid is not a general number
// AssignTo assigns from src to dst. Note that as CID is not a general number
// type AssignTo does not do automatic type conversion as other number types do.
func (src *Cid) AssignTo(dst interface{}) error {
func (src *CID) AssignTo(dst interface{}) error {
return (*pguint32)(src).AssignTo(dst)
}
func (dst *Cid) DecodeText(ci *ConnInfo, src []byte) error {
func (dst *CID) DecodeText(ci *ConnInfo, src []byte) error {
return (*pguint32)(dst).DecodeText(ci, src)
}
func (dst *Cid) DecodeBinary(ci *ConnInfo, src []byte) error {
func (dst *CID) DecodeBinary(ci *ConnInfo, src []byte) error {
return (*pguint32)(dst).DecodeBinary(ci, src)
}
func (src *Cid) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
func (src *CID) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
return (*pguint32)(src).EncodeText(ci, buf)
}
func (src *Cid) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
func (src *CID) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
return (*pguint32)(src).EncodeBinary(ci, buf)
}
// Scan implements the database/sql Scanner interface.
func (dst *Cid) Scan(src interface{}) error {
func (dst *CID) Scan(src interface{}) error {
return (*pguint32)(dst).Scan(src)
}
// Value implements the database/sql/driver Valuer interface.
func (src *Cid) Value() (driver.Value, error) {
func (src *CID) Value() (driver.Value, error) {
return (*pguint32)(src).Value()
}

30
cid_test.go
View File

@ -8,11 +8,11 @@ import (
"github.com/jackc/pgx/pgtype/testutil"
)
func TestCidTranscode(t *testing.T) {
func TestCIDTranscode(t *testing.T) {
pgTypeName := "cid"
values := []interface{}{
&pgtype.Cid{Uint: 42, Status: pgtype.Present},
&pgtype.Cid{Status: pgtype.Null},
&pgtype.CID{Uint: 42, Status: pgtype.Present},
&pgtype.CID{Status: pgtype.Null},
}
eqFunc := func(a, b interface{}) bool {
return reflect.DeepEqual(a, b)
@ -28,16 +28,16 @@ func TestCidTranscode(t *testing.T) {
}
}
func TestCidSet(t *testing.T) {
func TestCIDSet(t *testing.T) {
successfulTests := []struct {
source interface{}
result pgtype.Cid
result pgtype.CID
}{
{source: uint32(1), result: pgtype.Cid{Uint: 1, Status: pgtype.Present}},
{source: uint32(1), result: pgtype.CID{Uint: 1, Status: pgtype.Present}},
}
for i, tt := range successfulTests {
var r pgtype.Cid
var r pgtype.CID
err := r.Set(tt.source)
if err != nil {
t.Errorf("%d: %v", i, err)
@ -49,17 +49,17 @@ func TestCidSet(t *testing.T) {
}
}
func TestCidAssignTo(t *testing.T) {
func TestCIDAssignTo(t *testing.T) {
var ui32 uint32
var pui32 *uint32
simpleTests := []struct {
src pgtype.Cid
src pgtype.CID
dst interface{}
expected interface{}
}{
{src: pgtype.Cid{Uint: 42, Status: pgtype.Present}, dst: &ui32, expected: uint32(42)},
{src: pgtype.Cid{Status: pgtype.Null}, dst: &pui32, expected: ((*uint32)(nil))},
{src: pgtype.CID{Uint: 42, Status: pgtype.Present}, dst: &ui32, expected: uint32(42)},
{src: pgtype.CID{Status: pgtype.Null}, dst: &pui32, expected: ((*uint32)(nil))},
}
for i, tt := range simpleTests {
@ -74,11 +74,11 @@ func TestCidAssignTo(t *testing.T) {
}
pointerAllocTests := []struct {
src pgtype.Cid
src pgtype.CID
dst interface{}
expected interface{}
}{
{src: pgtype.Cid{Uint: 42, Status: pgtype.Present}, dst: &pui32, expected: uint32(42)},
{src: pgtype.CID{Uint: 42, Status: pgtype.Present}, dst: &pui32, expected: uint32(42)},
}
for i, tt := range pointerAllocTests {
@ -93,10 +93,10 @@ func TestCidAssignTo(t *testing.T) {
}
errorTests := []struct {
src pgtype.Cid
src pgtype.CID
dst interface{}
}{
{src: pgtype.Cid{Status: pgtype.Null}, dst: &ui32},
{src: pgtype.CID{Status: pgtype.Null}, dst: &ui32},
}
for i, tt := range errorTests {

16
cidr.go
View File

@ -1,31 +1,31 @@
package pgtype
type Cidr Inet
type CIDR Inet
func (dst *Cidr) Set(src interface{}) error {
func (dst *CIDR) Set(src interface{}) error {
return (*Inet)(dst).Set(src)
}
func (dst *Cidr) Get() interface{} {
func (dst *CIDR) Get() interface{} {
return (*Inet)(dst).Get()
}
func (src *Cidr) AssignTo(dst interface{}) error {
func (src *CIDR) AssignTo(dst interface{}) error {
return (*Inet)(src).AssignTo(dst)
}
func (dst *Cidr) DecodeText(ci *ConnInfo, src []byte) error {
func (dst *CIDR) DecodeText(ci *ConnInfo, src []byte) error {
return (*Inet)(dst).DecodeText(ci, src)
}
func (dst *Cidr) DecodeBinary(ci *ConnInfo, src []byte) error {
func (dst *CIDR) DecodeBinary(ci *ConnInfo, src []byte) error {
return (*Inet)(dst).DecodeBinary(ci, src)
}
func (src *Cidr) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
func (src *CIDR) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
return (*Inet)(src).EncodeText(ci, buf)
}
func (src *Cidr) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
func (src *CIDR) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
return (*Inet)(src).EncodeBinary(ci, buf)
}

58
cidr_array.go
View File

@ -9,28 +9,28 @@ import (
"github.com/jackc/pgx/pgio"
)
type CidrArray struct {
Elements []Cidr
type CIDRArray struct {
Elements []CIDR
Dimensions []ArrayDimension
Status Status
}
func (dst *CidrArray) Set(src interface{}) error {
func (dst *CIDRArray) Set(src interface{}) error {
switch value := src.(type) {
case []*net.IPNet:
if value == nil {
*dst = CidrArray{Status: Null}
*dst = CIDRArray{Status: Null}
} else if len(value) == 0 {
*dst = CidrArray{Status: Present}
*dst = CIDRArray{Status: Present}
} else {
elements := make([]Cidr, len(value))
elements := make([]CIDR, len(value))
for i := range value {
if err := elements[i].Set(value[i]); err != nil {
return err
}
}
*dst = CidrArray{
*dst = CIDRArray{
Elements: elements,
Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}},
Status: Present,
@ -39,17 +39,17 @@ func (dst *CidrArray) Set(src interface{}) error {
case []net.IP:
if value == nil {
*dst = CidrArray{Status: Null}
*dst = CIDRArray{Status: Null}
} else if len(value) == 0 {
*dst = CidrArray{Status: Present}
*dst = CIDRArray{Status: Present}
} else {
elements := make([]Cidr, len(value))
elements := make([]CIDR, len(value))
for i := range value {
if err := elements[i].Set(value[i]); err != nil {
return err
}
}
*dst = CidrArray{
*dst = CIDRArray{
Elements: elements,
Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}},
Status: Present,
@ -60,13 +60,13 @@ func (dst *CidrArray) Set(src interface{}) error {
if originalSrc, ok := underlyingSliceType(src); ok {
return dst.Set(originalSrc)
}
return fmt.Errorf("cannot convert %v to Cidr", value)
return fmt.Errorf("cannot convert %v to CIDR", value)
}
return nil
}
func (dst *CidrArray) Get() interface{} {
func (dst *CIDRArray) Get() interface{} {
switch dst.Status {
case Present:
return dst
@ -77,7 +77,7 @@ func (dst *CidrArray) Get() interface{} {
}
}
func (src *CidrArray) AssignTo(dst interface{}) error {
func (src *CIDRArray) AssignTo(dst interface{}) error {
switch src.Status {
case Present:
switch v := dst.(type) {
@ -112,9 +112,9 @@ func (src *CidrArray) AssignTo(dst interface{}) error {
return fmt.Errorf("cannot decode %v into %T", src, dst)
}
func (dst *CidrArray) DecodeText(ci *ConnInfo, src []byte) error {
func (dst *CIDRArray) DecodeText(ci *ConnInfo, src []byte) error {
if src == nil {
*dst = CidrArray{Status: Null}
*dst = CIDRArray{Status: Null}
return nil
}
@ -123,13 +123,13 @@ func (dst *CidrArray) DecodeText(ci *ConnInfo, src []byte) error {
return err
}
var elements []Cidr
var elements []CIDR
if len(uta.Elements) > 0 {
elements = make([]Cidr, len(uta.Elements))
elements = make([]CIDR, len(uta.Elements))
for i, s := range uta.Elements {
var elem Cidr
var elem CIDR
var elemSrc []byte
if s != "NULL" {
elemSrc = []byte(s)
@ -143,14 +143,14 @@ func (dst *CidrArray) DecodeText(ci *ConnInfo, src []byte) error {
}
}
*dst = CidrArray{Elements: elements, Dimensions: uta.Dimensions, Status: Present}
*dst = CIDRArray{Elements: elements, Dimensions: uta.Dimensions, Status: Present}
return nil
}
func (dst *CidrArray) DecodeBinary(ci *ConnInfo, src []byte) error {
func (dst *CIDRArray) DecodeBinary(ci *ConnInfo, src []byte) error {
if src == nil {
*dst = CidrArray{Status: Null}
*dst = CIDRArray{Status: Null}
return nil
}
@ -161,7 +161,7 @@ func (dst *CidrArray) DecodeBinary(ci *ConnInfo, src []byte) error {
}
if len(arrayHeader.Dimensions) == 0 {
*dst = CidrArray{Dimensions: arrayHeader.Dimensions, Status: Present}
*dst = CIDRArray{Dimensions: arrayHeader.Dimensions, Status: Present}
return nil
}
@ -170,7 +170,7 @@ func (dst *CidrArray) DecodeBinary(ci *ConnInfo, src []byte) error {
elementCount *= d.Length
}
elements := make([]Cidr, elementCount)
elements := make([]CIDR, elementCount)
for i := range elements {
elemLen := int(int32(binary.BigEndian.Uint32(src[rp:])))
@ -186,11 +186,11 @@ func (dst *CidrArray) DecodeBinary(ci *ConnInfo, src []byte) error {
}
}
*dst = CidrArray{Elements: elements, Dimensions: arrayHeader.Dimensions, Status: Present}
*dst = CIDRArray{Elements: elements, Dimensions: arrayHeader.Dimensions, Status: Present}
return nil
}
func (src *CidrArray) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
func (src *CIDRArray) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
switch src.Status {
case Null:
return nil, nil
@ -247,7 +247,7 @@ func (src *CidrArray) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
return buf, nil
}
func (src *CidrArray) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
func (src *CIDRArray) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
switch src.Status {
case Null:
return nil, nil
@ -292,7 +292,7 @@ func (src *CidrArray) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
}
// Scan implements the database/sql Scanner interface.
func (dst *CidrArray) Scan(src interface{}) error {
func (dst *CIDRArray) Scan(src interface{}) error {
if src == nil {
return dst.DecodeText(nil, nil)
}
@ -310,7 +310,7 @@ func (dst *CidrArray) Scan(src interface{}) error {
}
// Value implements the database/sql/driver Valuer interface.
func (src *CidrArray) Value() (driver.Value, error) {
func (src *CIDRArray) Value() (driver.Value, error) {
buf, err := src.EncodeText(nil, nil)
if err != nil {
return nil, err

92
cidr_array_test.go
View File

@ -9,40 +9,40 @@ import (
"github.com/jackc/pgx/pgtype/testutil"
)
func TestCidrArrayTranscode(t *testing.T) {
func TestCIDRArrayTranscode(t *testing.T) {
testutil.TestSuccessfulTranscode(t, "cidr[]", []interface{}{
&pgtype.CidrArray{
&pgtype.CIDRArray{
Elements: nil,
Dimensions: nil,
Status: pgtype.Present,
},
&pgtype.CidrArray{
Elements: []pgtype.Cidr{
pgtype.Cidr{IPNet: mustParseCidr(t, "12.34.56.0/32"), Status: pgtype.Present},
pgtype.Cidr{Status: pgtype.Null},
&pgtype.CIDRArray{
Elements: []pgtype.CIDR{
pgtype.CIDR{IPNet: mustParseCIDR(t, "12.34.56.0/32"), Status: pgtype.Present},
pgtype.CIDR{Status: pgtype.Null},
},
Dimensions: []pgtype.ArrayDimension{{Length: 2, LowerBound: 1}},
Status: pgtype.Present,
},
&pgtype.CidrArray{Status: pgtype.Null},
&pgtype.CidrArray{
Elements: []pgtype.Cidr{
pgtype.Cidr{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present},
pgtype.Cidr{IPNet: mustParseCidr(t, "12.34.56.0/32"), Status: pgtype.Present},
pgtype.Cidr{IPNet: mustParseCidr(t, "192.168.0.1/32"), Status: pgtype.Present},
pgtype.Cidr{IPNet: mustParseCidr(t, "2607:f8b0:4009:80b::200e/128"), Status: pgtype.Present},
pgtype.Cidr{Status: pgtype.Null},
pgtype.Cidr{IPNet: mustParseCidr(t, "255.0.0.0/8"), Status: pgtype.Present},
&pgtype.CIDRArray{Status: pgtype.Null},
&pgtype.CIDRArray{
Elements: []pgtype.CIDR{
pgtype.CIDR{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present},
pgtype.CIDR{IPNet: mustParseCIDR(t, "12.34.56.0/32"), Status: pgtype.Present},
pgtype.CIDR{IPNet: mustParseCIDR(t, "192.168.0.1/32"), Status: pgtype.Present},
pgtype.CIDR{IPNet: mustParseCIDR(t, "2607:f8b0:4009:80b::200e/128"), Status: pgtype.Present},
pgtype.CIDR{Status: pgtype.Null},
pgtype.CIDR{IPNet: mustParseCIDR(t, "255.0.0.0/8"), Status: pgtype.Present},
},
Dimensions: []pgtype.ArrayDimension{{Length: 3, LowerBound: 1}, {Length: 2, LowerBound: 1}},
Status: pgtype.Present,
},
&pgtype.CidrArray{
Elements: []pgtype.Cidr{
pgtype.Cidr{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present},
pgtype.Cidr{IPNet: mustParseCidr(t, "12.34.56.0/32"), Status: pgtype.Present},
pgtype.Cidr{IPNet: mustParseCidr(t, "192.168.0.1/32"), Status: pgtype.Present},
pgtype.Cidr{IPNet: mustParseCidr(t, "2607:f8b0:4009:80b::200e/128"), Status: pgtype.Present},
&pgtype.CIDRArray{
Elements: []pgtype.CIDR{
pgtype.CIDR{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present},
pgtype.CIDR{IPNet: mustParseCIDR(t, "12.34.56.0/32"), Status: pgtype.Present},
pgtype.CIDR{IPNet: mustParseCIDR(t, "192.168.0.1/32"), Status: pgtype.Present},
pgtype.CIDR{IPNet: mustParseCIDR(t, "2607:f8b0:4009:80b::200e/128"), Status: pgtype.Present},
},
Dimensions: []pgtype.ArrayDimension{
{Length: 2, LowerBound: 4},
@ -53,37 +53,37 @@ func TestCidrArrayTranscode(t *testing.T) {
})
}
func TestCidrArraySet(t *testing.T) {
func TestCIDRArraySet(t *testing.T) {
successfulTests := []struct {
source interface{}
result pgtype.CidrArray
result pgtype.CIDRArray
}{
{
source: []*net.IPNet{mustParseCidr(t, "127.0.0.1/32")},
result: pgtype.CidrArray{
Elements: []pgtype.Cidr{{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}},
source: []*net.IPNet{mustParseCIDR(t, "127.0.0.1/32")},
result: pgtype.CIDRArray{
Elements: []pgtype.CIDR{{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}},
Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}},
Status: pgtype.Present},
},
{
source: (([]*net.IPNet)(nil)),
result: pgtype.CidrArray{Status: pgtype.Null},
result: pgtype.CIDRArray{Status: pgtype.Null},
},
{
source: []net.IP{mustParseCidr(t, "127.0.0.1/32").IP},
result: pgtype.CidrArray{
Elements: []pgtype.Cidr{{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}},
source: []net.IP{mustParseCIDR(t, "127.0.0.1/32").IP},
result: pgtype.CIDRArray{
Elements: []pgtype.CIDR{{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}},
Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}},
Status: pgtype.Present},
},
{
source: (([]net.IP)(nil)),
result: pgtype.CidrArray{Status: pgtype.Null},
result: pgtype.CIDRArray{Status: pgtype.Null},
},
}
for i, tt := range successfulTests {
var r pgtype.CidrArray
var r pgtype.CIDRArray
err := r.Set(tt.source)
if err != nil {
t.Errorf("%d: %v", i, err)
@ -95,27 +95,27 @@ func TestCidrArraySet(t *testing.T) {
}
}
func TestCidrArrayAssignTo(t *testing.T) {
func TestCIDRArrayAssignTo(t *testing.T) {
var ipnetSlice []*net.IPNet
var ipSlice []net.IP
simpleTests := []struct {
src pgtype.CidrArray
src pgtype.CIDRArray
dst interface{}
expected interface{}
}{
{
src: pgtype.CidrArray{
Elements: []pgtype.Cidr{{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}},
src: pgtype.CIDRArray{
Elements: []pgtype.CIDR{{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}},
Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}},
Status: pgtype.Present,
},
dst: &ipnetSlice,
expected: []*net.IPNet{mustParseCidr(t, "127.0.0.1/32")},
expected: []*net.IPNet{mustParseCIDR(t, "127.0.0.1/32")},
},
{
src: pgtype.CidrArray{
Elements: []pgtype.Cidr{{Status: pgtype.Null}},
src: pgtype.CIDRArray{
Elements: []pgtype.CIDR{{Status: pgtype.Null}},
Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}},
Status: pgtype.Present,
},
@ -123,17 +123,17 @@ func TestCidrArrayAssignTo(t *testing.T) {
expected: []*net.IPNet{nil},
},
{
src: pgtype.CidrArray{
Elements: []pgtype.Cidr{{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}},
src: pgtype.CIDRArray{
Elements: []pgtype.CIDR{{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}},
Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}},
Status: pgtype.Present,
},
dst: &ipSlice,
expected: []net.IP{mustParseCidr(t, "127.0.0.1/32").IP},
expected: []net.IP{mustParseCIDR(t, "127.0.0.1/32").IP},
},
{
src: pgtype.CidrArray{
Elements: []pgtype.Cidr{{Status: pgtype.Null}},
src: pgtype.CIDRArray{
Elements: []pgtype.CIDR{{Status: pgtype.Null}},
Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}},
Status: pgtype.Present,
},
@ -141,12 +141,12 @@ func TestCidrArrayAssignTo(t *testing.T) {
expected: []net.IP{nil},
},
{
src: pgtype.CidrArray{Status: pgtype.Null},
src: pgtype.CIDRArray{Status: pgtype.Null},
dst: &ipnetSlice,
expected: (([]*net.IPNet)(nil)),
},
{
src: pgtype.CidrArray{Status: pgtype.Null},
src: pgtype.CIDRArray{Status: pgtype.Null},
dst: &ipSlice,
expected: (([]net.IP)(nil)),
},

36
inet_array_test.go
View File

@ -18,7 +18,7 @@ func TestInetArrayTranscode(t *testing.T) {
},
&pgtype.InetArray{
Elements: []pgtype.Inet{
pgtype.Inet{IPNet: mustParseCidr(t, "12.34.56.0/32"), Status: pgtype.Present},
pgtype.Inet{IPNet: mustParseCIDR(t, "12.34.56.0/32"), Status: pgtype.Present},
pgtype.Inet{Status: pgtype.Null},
},
Dimensions: []pgtype.ArrayDimension{{Length: 2, LowerBound: 1}},
@ -27,22 +27,22 @@ func TestInetArrayTranscode(t *testing.T) {
&pgtype.InetArray{Status: pgtype.Null},
&pgtype.InetArray{
Elements: []pgtype.Inet{
pgtype.Inet{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present},
pgtype.Inet{IPNet: mustParseCidr(t, "12.34.56.0/32"), Status: pgtype.Present},
pgtype.Inet{IPNet: mustParseCidr(t, "192.168.0.1/32"), Status: pgtype.Present},
pgtype.Inet{IPNet: mustParseCidr(t, "2607:f8b0:4009:80b::200e/128"), Status: pgtype.Present},
pgtype.Inet{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present},
pgtype.Inet{IPNet: mustParseCIDR(t, "12.34.56.0/32"), Status: pgtype.Present},
pgtype.Inet{IPNet: mustParseCIDR(t, "192.168.0.1/32"), Status: pgtype.Present},
pgtype.Inet{IPNet: mustParseCIDR(t, "2607:f8b0:4009:80b::200e/128"), Status: pgtype.Present},
pgtype.Inet{Status: pgtype.Null},
pgtype.Inet{IPNet: mustParseCidr(t, "255.0.0.0/8"), Status: pgtype.Present},
pgtype.Inet{IPNet: mustParseCIDR(t, "255.0.0.0/8"), Status: pgtype.Present},
},
Dimensions: []pgtype.ArrayDimension{{Length: 3, LowerBound: 1}, {Length: 2, LowerBound: 1}},
Status: pgtype.Present,
},
&pgtype.InetArray{
Elements: []pgtype.Inet{
pgtype.Inet{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present},
pgtype.Inet{IPNet: mustParseCidr(t, "12.34.56.0/32"), Status: pgtype.Present},
pgtype.Inet{IPNet: mustParseCidr(t, "192.168.0.1/32"), Status: pgtype.Present},
pgtype.Inet{IPNet: mustParseCidr(t, "2607:f8b0:4009:80b::200e/128"), Status: pgtype.Present},
pgtype.Inet{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present},
pgtype.Inet{IPNet: mustParseCIDR(t, "12.34.56.0/32"), Status: pgtype.Present},
pgtype.Inet{IPNet: mustParseCIDR(t, "192.168.0.1/32"), Status: pgtype.Present},
pgtype.Inet{IPNet: mustParseCIDR(t, "2607:f8b0:4009:80b::200e/128"), Status: pgtype.Present},
},
Dimensions: []pgtype.ArrayDimension{
{Length: 2, LowerBound: 4},
@ -59,9 +59,9 @@ func TestInetArraySet(t *testing.T) {
result pgtype.InetArray
}{
{
source: []*net.IPNet{mustParseCidr(t, "127.0.0.1/32")},
source: []*net.IPNet{mustParseCIDR(t, "127.0.0.1/32")},
result: pgtype.InetArray{
Elements: []pgtype.Inet{{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}},
Elements: []pgtype.Inet{{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}},
Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}},
Status: pgtype.Present},
},
@ -70,9 +70,9 @@ func TestInetArraySet(t *testing.T) {
result: pgtype.InetArray{Status: pgtype.Null},
},
{
source: []net.IP{mustParseCidr(t, "127.0.0.1/32").IP},
source: []net.IP{mustParseCIDR(t, "127.0.0.1/32").IP},
result: pgtype.InetArray{
Elements: []pgtype.Inet{{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}},
Elements: []pgtype.Inet{{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}},
Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}},
Status: pgtype.Present},
},
@ -106,12 +106,12 @@ func TestInetArrayAssignTo(t *testing.T) {
}{
{
src: pgtype.InetArray{
Elements: []pgtype.Inet{{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}},
Elements: []pgtype.Inet{{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}},
Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}},
Status: pgtype.Present,
},
dst: &ipnetSlice,
expected: []*net.IPNet{mustParseCidr(t, "127.0.0.1/32")},
expected: []*net.IPNet{mustParseCIDR(t, "127.0.0.1/32")},
},
{
src: pgtype.InetArray{
@ -124,12 +124,12 @@ func TestInetArrayAssignTo(t *testing.T) {
},
{
src: pgtype.InetArray{
Elements: []pgtype.Inet{{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}},
Elements: []pgtype.Inet{{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}},
Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}},
Status: pgtype.Present,
},
dst: &ipSlice,
expected: []net.IP{mustParseCidr(t, "127.0.0.1/32").IP},
expected: []net.IP{mustParseCIDR(t, "127.0.0.1/32").IP},
},
{
src: pgtype.InetArray{

36
inet_test.go
View File

@ -12,16 +12,16 @@ import (
func TestInetTranscode(t *testing.T) {
for _, pgTypeName := range []string{"inet", "cidr"} {
testutil.TestSuccessfulTranscode(t, pgTypeName, []interface{}{
&pgtype.Inet{IPNet: mustParseCidr(t, "0.0.0.0/32"), Status: pgtype.Present},
&pgtype.Inet{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present},
&pgtype.Inet{IPNet: mustParseCidr(t, "12.34.56.0/32"), Status: pgtype.Present},
&pgtype.Inet{IPNet: mustParseCidr(t, "192.168.1.0/24"), Status: pgtype.Present},
&pgtype.Inet{IPNet: mustParseCidr(t, "255.0.0.0/8"), Status: pgtype.Present},
&pgtype.Inet{IPNet: mustParseCidr(t, "255.255.255.255/32"), Status: pgtype.Present},
&pgtype.Inet{IPNet: mustParseCidr(t, "::/128"), Status: pgtype.Present},
&pgtype.Inet{IPNet: mustParseCidr(t, "::/0"), Status: pgtype.Present},
&pgtype.Inet{IPNet: mustParseCidr(t, "::1/128"), Status: pgtype.Present},
&pgtype.Inet{IPNet: mustParseCidr(t, "2607:f8b0:4009:80b::200e/128"), Status: pgtype.Present},
&pgtype.Inet{IPNet: mustParseCIDR(t, "0.0.0.0/32"), Status: pgtype.Present},
&pgtype.Inet{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present},
&pgtype.Inet{IPNet: mustParseCIDR(t, "12.34.56.0/32"), Status: pgtype.Present},
&pgtype.Inet{IPNet: mustParseCIDR(t, "192.168.1.0/24"), Status: pgtype.Present},
&pgtype.Inet{IPNet: mustParseCIDR(t, "255.0.0.0/8"), Status: pgtype.Present},
&pgtype.Inet{IPNet: mustParseCIDR(t, "255.255.255.255/32"), Status: pgtype.Present},
&pgtype.Inet{IPNet: mustParseCIDR(t, "::/128"), Status: pgtype.Present},
&pgtype.Inet{IPNet: mustParseCIDR(t, "::/0"), Status: pgtype.Present},
&pgtype.Inet{IPNet: mustParseCIDR(t, "::1/128"), Status: pgtype.Present},
&pgtype.Inet{IPNet: mustParseCIDR(t, "2607:f8b0:4009:80b::200e/128"), Status: pgtype.Present},
&pgtype.Inet{Status: pgtype.Null},
})
}
@ -32,9 +32,9 @@ func TestInetSet(t *testing.T) {
source interface{}
result pgtype.Inet
}{
{source: mustParseCidr(t, "127.0.0.1/32"), result: pgtype.Inet{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}},
{source: mustParseCidr(t, "127.0.0.1/32").IP, result: pgtype.Inet{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}},
{source: "127.0.0.1/32", result: pgtype.Inet{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}},
{source: mustParseCIDR(t, "127.0.0.1/32"), result: pgtype.Inet{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}},
{source: mustParseCIDR(t, "127.0.0.1/32").IP, result: pgtype.Inet{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}},
{source: "127.0.0.1/32", result: pgtype.Inet{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}},
}
for i, tt := range successfulTests {
@ -61,8 +61,8 @@ func TestInetAssignTo(t *testing.T) {
dst interface{}
expected interface{}
}{
{src: pgtype.Inet{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}, dst: &ipnet, expected: *mustParseCidr(t, "127.0.0.1/32")},
{src: pgtype.Inet{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}, dst: &ip, expected: mustParseCidr(t, "127.0.0.1/32").IP},
{src: pgtype.Inet{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}, dst: &ipnet, expected: *mustParseCIDR(t, "127.0.0.1/32")},
{src: pgtype.Inet{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}, dst: &ip, expected: mustParseCIDR(t, "127.0.0.1/32").IP},
{src: pgtype.Inet{Status: pgtype.Null}, dst: &pipnet, expected: ((*net.IPNet)(nil))},
{src: pgtype.Inet{Status: pgtype.Null}, dst: &pip, expected: ((*net.IP)(nil))},
}
@ -83,8 +83,8 @@ func TestInetAssignTo(t *testing.T) {
dst interface{}
expected interface{}
}{
{src: pgtype.Inet{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}, dst: &pipnet, expected: *mustParseCidr(t, "127.0.0.1/32")},
{src: pgtype.Inet{IPNet: mustParseCidr(t, "127.0.0.1/32"), Status: pgtype.Present}, dst: &pip, expected: mustParseCidr(t, "127.0.0.1/32").IP},
{src: pgtype.Inet{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}, dst: &pipnet, expected: *mustParseCIDR(t, "127.0.0.1/32")},
{src: pgtype.Inet{IPNet: mustParseCIDR(t, "127.0.0.1/32"), Status: pgtype.Present}, dst: &pip, expected: mustParseCIDR(t, "127.0.0.1/32").IP},
}
for i, tt := range pointerAllocTests {
@ -102,7 +102,7 @@ func TestInetAssignTo(t *testing.T) {
src pgtype.Inet
dst interface{}
}{
{src: pgtype.Inet{IPNet: mustParseCidr(t, "192.168.0.0/16"), Status: pgtype.Present}, dst: &ip},
{src: pgtype.Inet{IPNet: mustParseCIDR(t, "192.168.0.0/16"), Status: pgtype.Present}, dst: &ip},
{src: pgtype.Inet{Status: pgtype.Null}, dst: &ipnet},
}

20
pgtype.go
View File

@ -16,12 +16,12 @@ const (
Int4OID = 23
TextOID = 25
OIDOID = 26
TidOID = 27
XidOID = 28
CidOID = 29
TIDOID = 27
XIDOID = 28
CIDOID = 29
JSONOID = 114
CidrOID = 650
CidrArrayOID = 651
CIDROID = 650
CIDRArrayOID = 651
Float4OID = 700
Float8OID = 701
UnknownOID = 705
@ -209,7 +209,7 @@ func init() {
"_aclitem": &ACLItemArray{},
"_bool": &BoolArray{},
"_bytea": &ByteaArray{},
"_cidr": &CidrArray{},
"_cidr": &CIDRArray{},
"_date": &DateArray{},
"_float4": &Float4Array{},
"_float8": &Float8Array{},
@ -227,8 +227,8 @@ func init() {
"box": &Box{},
"bytea": &Bytea{},
"char": &QChar{},
"cid": &Cid{},
"cidr": &Cidr{},
"cid": &CID{},
"cidr": &CIDR{},
"circle": &Circle{},
"date": &Date{},
"daterange": &Daterange{},
@ -256,7 +256,7 @@ func init() {
"polygon": &Polygon{},
"record": &Record{},
"text": &Text{},
"tid": &Tid{},
"tid": &TID{},
"timestamp": &Timestamp{},
"timestamptz": &Timestamptz{},
"tsrange": &Tsrange{},
@ -265,6 +265,6 @@ func init() {
"uuid": &UUID{},
"varbit": &Varbit{},
"varchar": &Varchar{},
"xid": &Xid{},
"xid": &XID{},
}
}

2
pgtype_test.go
View File

@ -20,7 +20,7 @@ type _float32Slice []float32
type _float64Slice []float64
type _byteSlice []byte
func mustParseCidr(t testing.TB, s string) *net.IPNet {
func mustParseCIDR(t testing.TB, s string) *net.IPNet {
_, ipnet, err := net.ParseCIDR(s)
if err != nil {
t.Fatal(err)

2
pguint32.go
View File

@ -11,7 +11,7 @@ import (
)
// pguint32 is the core type that is used to implement PostgreSQL types such as
// Cid and Xid.
// CID and XID.
type pguint32 struct {
Uint uint32
Status Status

34
tid.go
View File

@ -10,7 +10,7 @@ import (
"github.com/jackc/pgx/pgio"
)
// Tid is PostgreSQL's Tuple Identifier type.
// TID is PostgreSQL's Tuple Identifier type.
//
// When one does
//
@ -21,17 +21,17 @@ import (
// It is currently implemented as a pair unsigned two byte integers.
// Its conversion functions can be found in src/backend/utils/adt/tid.c
// in the PostgreSQL sources.
type Tid struct {
type TID struct {
BlockNumber uint32
OffsetNumber uint16
Status Status
}
func (dst *Tid) Set(src interface{}) error {
return fmt.Errorf("cannot convert %v to Tid", src)
func (dst *TID) Set(src interface{}) error {
return fmt.Errorf("cannot convert %v to TID", src)
}
func (dst *Tid) Get() interface{} {
func (dst *TID) Get() interface{} {
switch dst.Status {
case Present:
return dst
@ -42,13 +42,13 @@ func (dst *Tid) Get() interface{} {
}
}
func (src *Tid) AssignTo(dst interface{}) error {
func (src *TID) AssignTo(dst interface{}) error {
return fmt.Errorf("cannot assign %v to %T", src, dst)
}
func (dst *Tid) DecodeText(ci *ConnInfo, src []byte) error {
func (dst *TID) DecodeText(ci *ConnInfo, src []byte) error {
if src == nil {
*dst = Tid{Status: Null}
*dst = TID{Status: Null}
return nil
}
@ -71,13 +71,13 @@ func (dst *Tid) DecodeText(ci *ConnInfo, src []byte) error {
return err
}
*dst = Tid{BlockNumber: uint32(blockNumber), OffsetNumber: uint16(offsetNumber), Status: Present}
*dst = TID{BlockNumber: uint32(blockNumber), OffsetNumber: uint16(offsetNumber), Status: Present}
return nil
}
func (dst *Tid) DecodeBinary(ci *ConnInfo, src []byte) error {
func (dst *TID) DecodeBinary(ci *ConnInfo, src []byte) error {
if src == nil {
*dst = Tid{Status: Null}
*dst = TID{Status: Null}
return nil
}
@ -85,7 +85,7 @@ func (dst *Tid) DecodeBinary(ci *ConnInfo, src []byte) error {
return fmt.Errorf("invalid length for tid: %v", len(src))
}
*dst = Tid{
*dst = TID{
BlockNumber: binary.BigEndian.Uint32(src),
OffsetNumber: binary.BigEndian.Uint16(src[4:]),
Status: Present,
@ -93,7 +93,7 @@ func (dst *Tid) DecodeBinary(ci *ConnInfo, src []byte) error {
return nil
}
func (src *Tid) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
func (src *TID) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
switch src.Status {
case Null:
return nil, nil
@ -105,7 +105,7 @@ func (src *Tid) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
return buf, nil
}
func (src *Tid) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
func (src *TID) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
switch src.Status {
case Null:
return nil, nil
@ -119,9 +119,9 @@ func (src *Tid) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
}
// Scan implements the database/sql Scanner interface.
func (dst *Tid) Scan(src interface{}) error {
func (dst *TID) Scan(src interface{}) error {
if src == nil {
*dst = Tid{Status: Null}
*dst = TID{Status: Null}
return nil
}
@ -138,6 +138,6 @@ func (dst *Tid) Scan(src interface{}) error {
}
// Value implements the database/sql/driver Valuer interface.
func (src *Tid) Value() (driver.Value, error) {
func (src *TID) Value() (driver.Value, error) {
return EncodeValueText(src)
}

8
tid_test.go
View File

@ -7,10 +7,10 @@ import (
"github.com/jackc/pgx/pgtype/testutil"
)
func TestTidTranscode(t *testing.T) {
func TestTIDTranscode(t *testing.T) {
testutil.TestSuccessfulTranscode(t, "tid", []interface{}{
&pgtype.Tid{BlockNumber: 42, OffsetNumber: 43, Status: pgtype.Present},
&pgtype.Tid{BlockNumber: 4294967295, OffsetNumber: 65535, Status: pgtype.Present},
&pgtype.Tid{Status: pgtype.Null},
&pgtype.TID{BlockNumber: 42, OffsetNumber: 43, Status: pgtype.Present},
&pgtype.TID{BlockNumber: 4294967295, OffsetNumber: 65535, Status: pgtype.Present},
&pgtype.TID{Status: pgtype.Null},
})
}

2
typed_array_gen.sh
View File

@ -8,7 +8,7 @@ erb pgtype_array_type=TimestampArray pgtype_element_type=Timestamp go_array_type
erb pgtype_array_type=Float4Array pgtype_element_type=Float4 go_array_types=[]float32 element_type_name=float4 text_null=NULL binary_format=true typed_array.go.erb > float4_array.go
erb pgtype_array_type=Float8Array pgtype_element_type=Float8 go_array_types=[]float64 element_type_name=float8 text_null=NULL binary_format=true typed_array.go.erb > float8_array.go
erb pgtype_array_type=InetArray pgtype_element_type=Inet go_array_types=[]*net.IPNet,[]net.IP element_type_name=inet text_null=NULL binary_format=true typed_array.go.erb > inet_array.go
erb pgtype_array_type=CidrArray pgtype_element_type=Cidr go_array_types=[]*net.IPNet,[]net.IP element_type_name=cidr text_null=NULL binary_format=true typed_array.go.erb > cidr_array.go
erb pgtype_array_type=CIDRArray pgtype_element_type=CIDR go_array_types=[]*net.IPNet,[]net.IP element_type_name=cidr text_null=NULL binary_format=true typed_array.go.erb > cidr_array.go
erb pgtype_array_type=TextArray pgtype_element_type=Text go_array_types=[]string element_type_name=text text_null='"NULL"' binary_format=true typed_array.go.erb > text_array.go
erb pgtype_array_type=VarcharArray pgtype_element_type=Varchar go_array_types=[]string element_type_name=varchar text_null='"NULL"' binary_format=true typed_array.go.erb > varchar_array.go
erb pgtype_array_type=ByteaArray pgtype_element_type=Bytea go_array_types=[][]byte element_type_name=bytea text_null=NULL binary_format=true typed_array.go.erb > bytea_array.go

26
xid.go
View File

@ -4,7 +4,7 @@ import (
"database/sql/driver"
)
// Xid is PostgreSQL's Transaction ID type.
// XID is PostgreSQL's Transaction ID type.
//
// In later versions of PostgreSQL, it is the type used for the backend_xid
// and backend_xmin columns of the pg_stat_activity system view.
@ -18,47 +18,47 @@ import (
// It is currently implemented as an unsigned four byte integer.
// Its definition can be found in src/include/postgres_ext.h as TransactionId
// in the PostgreSQL sources.
type Xid pguint32
type XID pguint32
// Set converts from src to dst. Note that as Xid is not a general
// Set converts from src to dst. Note that as XID is not a general
// number type Set does not do automatic type conversion as other number
// types do.
func (dst *Xid) Set(src interface{}) error {
func (dst *XID) Set(src interface{}) error {
return (*pguint32)(dst).Set(src)
}
func (dst *Xid) Get() interface{} {
func (dst *XID) Get() interface{} {
return (*pguint32)(dst).Get()
}
// AssignTo assigns from src to dst. Note that as Xid is not a general number
// AssignTo assigns from src to dst. Note that as XID is not a general number
// type AssignTo does not do automatic type conversion as other number types do.
func (src *Xid) AssignTo(dst interface{}) error {
func (src *XID) AssignTo(dst interface{}) error {
return (*pguint32)(src).AssignTo(dst)
}
func (dst *Xid) DecodeText(ci *ConnInfo, src []byte) error {
func (dst *XID) DecodeText(ci *ConnInfo, src []byte) error {
return (*pguint32)(dst).DecodeText(ci, src)
}
func (dst *Xid) DecodeBinary(ci *ConnInfo, src []byte) error {
func (dst *XID) DecodeBinary(ci *ConnInfo, src []byte) error {
return (*pguint32)(dst).DecodeBinary(ci, src)
}
func (src *Xid) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
func (src *XID) EncodeText(ci *ConnInfo, buf []byte) ([]byte, error) {
return (*pguint32)(src).EncodeText(ci, buf)
}
func (src *Xid) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
func (src *XID) EncodeBinary(ci *ConnInfo, buf []byte) ([]byte, error) {
return (*pguint32)(src).EncodeBinary(ci, buf)
}
// Scan implements the database/sql Scanner interface.
func (dst *Xid) Scan(src interface{}) error {
func (dst *XID) Scan(src interface{}) error {
return (*pguint32)(dst).Scan(src)
}
// Value implements the database/sql/driver Valuer interface.
func (src *Xid) Value() (driver.Value, error) {
func (src *XID) Value() (driver.Value, error) {
return (*pguint32)(src).Value()
}

30
xid_test.go
View File

@ -8,11 +8,11 @@ import (
"github.com/jackc/pgx/pgtype/testutil"
)
func TestXidTranscode(t *testing.T) {
func TestXIDTranscode(t *testing.T) {
pgTypeName := "xid"
values := []interface{}{
&pgtype.Xid{Uint: 42, Status: pgtype.Present},
&pgtype.Xid{Status: pgtype.Null},
&pgtype.XID{Uint: 42, Status: pgtype.Present},
&pgtype.XID{Status: pgtype.Null},
}
eqFunc := func(a, b interface{}) bool {
return reflect.DeepEqual(a, b)
@ -28,16 +28,16 @@ func TestXidTranscode(t *testing.T) {
}
}
func TestXidSet(t *testing.T) {
func TestXIDSet(t *testing.T) {
successfulTests := []struct {
source interface{}
result pgtype.Xid
result pgtype.XID
}{
{source: uint32(1), result: pgtype.Xid{Uint: 1, Status: pgtype.Present}},
{source: uint32(1), result: pgtype.XID{Uint: 1, Status: pgtype.Present}},
}
for i, tt := range successfulTests {
var r pgtype.Xid
var r pgtype.XID
err := r.Set(tt.source)
if err != nil {
t.Errorf("%d: %v", i, err)
@ -49,17 +49,17 @@ func TestXidSet(t *testing.T) {
}
}
func TestXidAssignTo(t *testing.T) {
func TestXIDAssignTo(t *testing.T) {
var ui32 uint32
var pui32 *uint32
simpleTests := []struct {
src pgtype.Xid
src pgtype.XID
dst interface{}
expected interface{}
}{
{src: pgtype.Xid{Uint: 42, Status: pgtype.Present}, dst: &ui32, expected: uint32(42)},
{src: pgtype.Xid{Status: pgtype.Null}, dst: &pui32, expected: ((*uint32)(nil))},
{src: pgtype.XID{Uint: 42, Status: pgtype.Present}, dst: &ui32, expected: uint32(42)},
{src: pgtype.XID{Status: pgtype.Null}, dst: &pui32, expected: ((*uint32)(nil))},
}
for i, tt := range simpleTests {
@ -74,11 +74,11 @@ func TestXidAssignTo(t *testing.T) {
}
pointerAllocTests := []struct {
src pgtype.Xid
src pgtype.XID
dst interface{}
expected interface{}
}{
{src: pgtype.Xid{Uint: 42, Status: pgtype.Present}, dst: &pui32, expected: uint32(42)},
{src: pgtype.XID{Uint: 42, Status: pgtype.Present}, dst: &pui32, expected: uint32(42)},
}
for i, tt := range pointerAllocTests {
@ -93,10 +93,10 @@ func TestXidAssignTo(t *testing.T) {
}
errorTests := []struct {
src pgtype.Xid
src pgtype.XID
dst interface{}
}{
{src: pgtype.Xid{Status: pgtype.Null}, dst: &ui32},
{src: pgtype.XID{Status: pgtype.Null}, dst: &ui32},
}
for i, tt := range errorTests {