Move ACLItem to pgtype

aclitem.go

@@ -0,0 +1,104 @@
+package pgtype
+
+import (
+	"fmt"
+	"io"
+	"reflect"
+)
+
+// ACLItem is used for PostgreSQL's aclitem data type. A sample aclitem
+// might look like this:
+//
+//	postgres=arwdDxt/postgres
+//
+// Note, however, that because the user/role name part of an aclitem is
+// an identifier, it follows all the usual formatting rules for SQL
+// identifiers: if it contains spaces and other special characters,
+// it should appear in double-quotes:
+//
+//	postgres=arwdDxt/"role with spaces"
+//
+type ACLItem struct {
+	String string
+	Status Status
+}
+
+func (dst *ACLItem) ConvertFrom(src interface{}) error {
+	switch value := src.(type) {
+	case ACLItem:
+		*dst = value
+	case string:
+		*dst = ACLItem{String: value, Status: Present}
+	case *string:
+		if value == nil {
+			*dst = ACLItem{Status: Null}
+		} else {
+			*dst = ACLItem{String: *value, Status: Present}
+		}
+	default:
+		if originalSrc, ok := underlyingStringType(src); ok {
+			return dst.ConvertFrom(originalSrc)
+		}
+		return fmt.Errorf("cannot convert %v to ACLItem", value)
+	}
+
+	return nil
+}
+
+func (src *ACLItem) AssignTo(dst interface{}) error {
+	switch v := dst.(type) {
+	case *string:
+		if src.Status != Present {
+			return fmt.Errorf("cannot assign %v to %T", src, dst)
+		}
+		*v = src.String
+	default:
+		if v := reflect.ValueOf(dst); v.Kind() == reflect.Ptr {
+			el := v.Elem()
+			switch el.Kind() {
+			// if dst is a pointer to pointer, strip the pointer and try again
+			case reflect.Ptr:
+				if src.Status == Null {
+					el.Set(reflect.Zero(el.Type()))
+					return nil
+				}
+				if el.IsNil() {
+					// allocate destination
+					el.Set(reflect.New(el.Type().Elem()))
+				}
+				return src.AssignTo(el.Interface())
+			case reflect.String:
+				if src.Status != Present {
+					return fmt.Errorf("cannot assign %v to %T", src, dst)
+				}
+				el.SetString(src.String)
+				return nil
+			}
+		}
+		return fmt.Errorf("cannot decode %v into %T", src, dst)
+	}
+
+	return nil
+}
+
+func (dst *ACLItem) DecodeText(src []byte) error {
+	if src == nil {
+		*dst = ACLItem{Status: Null}
+		return nil
+	}
+
+	*dst = ACLItem{String: string(src), Status: Present}
+	return nil
+}
+
+func (src ACLItem) EncodeText(w io.Writer) (bool, error) {
+	switch src.Status {
+	case Null:
+		return true, nil
+	case Undefined:
+		return false, errUndefined
+	}
+
+	_, err := io.WriteString(w, src.String)
+	return false, err
+}

aclitem_test.go

@@ -0,0 +1,97 @@
+package pgtype_test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/jackc/pgx/pgtype"
+)
+
+func TestACLItemTranscode(t *testing.T) {
+	testSuccessfulTranscode(t, "aclitem", []interface{}{
+		pgtype.ACLItem{String: "postgres=arwdDxt/postgres", Status: pgtype.Present},
+		pgtype.ACLItem{String: `postgres=arwdDxt/" tricky, ' } "" \ test user "`, Status: pgtype.Present},
+		pgtype.ACLItem{Status: pgtype.Null},
+	})
+}
+
+func TestACLItemConvertFrom(t *testing.T) {
+	successfulTests := []struct {
+		source interface{}
+		result pgtype.ACLItem
+	}{
+		{source: pgtype.ACLItem{String: "postgres=arwdDxt/postgres", Status: pgtype.Present}, result: pgtype.ACLItem{String: "postgres=arwdDxt/postgres", Status: pgtype.Present}},
+		{source: "postgres=arwdDxt/postgres", result: pgtype.ACLItem{String: "postgres=arwdDxt/postgres", Status: pgtype.Present}},
+		{source: (*string)(nil), result: pgtype.ACLItem{Status: pgtype.Null}},
+	}
+
+	for i, tt := range successfulTests {
+		var d pgtype.ACLItem
+		err := d.ConvertFrom(tt.source)
+		if err != nil {
+			t.Errorf("%d: %v", i, err)
+		}
+
+		if d != tt.result {
+			t.Errorf("%d: expected %v to convert to %v, but it was %v", i, tt.source, tt.result, d)
+		}
+	}
+}
+
+func TestACLItemAssignTo(t *testing.T) {
+	var s string
+	var ps *string
+
+	simpleTests := []struct {
+		src      pgtype.ACLItem
+		dst      interface{}
+		expected interface{}
+	}{
+		{src: pgtype.ACLItem{String: "postgres=arwdDxt/postgres", Status: pgtype.Present}, dst: &s, expected: "postgres=arwdDxt/postgres"},
+		{src: pgtype.ACLItem{Status: pgtype.Null}, dst: &ps, expected: ((*string)(nil))},
+	}
+
+	for i, tt := range simpleTests {
+		err := tt.src.AssignTo(tt.dst)
+		if err != nil {
+			t.Errorf("%d: %v", i, err)
+		}
+
+		if dst := reflect.ValueOf(tt.dst).Elem().Interface(); dst != tt.expected {
+			t.Errorf("%d: expected %v to assign %v, but result was %v", i, tt.src, tt.expected, dst)
+		}
+	}
+
+	pointerAllocTests := []struct {
+		src      pgtype.ACLItem
+		dst      interface{}
+		expected interface{}
+	}{
+		{src: pgtype.ACLItem{String: "postgres=arwdDxt/postgres", Status: pgtype.Present}, dst: &ps, expected: "postgres=arwdDxt/postgres"},
+	}
+
+	for i, tt := range pointerAllocTests {
+		err := tt.src.AssignTo(tt.dst)
+		if err != nil {
+			t.Errorf("%d: %v", i, err)
+		}
+
+		if dst := reflect.ValueOf(tt.dst).Elem().Elem().Interface(); dst != tt.expected {
+			t.Errorf("%d: expected %v to assign %v, but result was %v", i, tt.src, tt.expected, dst)
+		}
+	}
+
+	errorTests := []struct {
+		src pgtype.ACLItem
+		dst interface{}
+	}{
+		{src: pgtype.ACLItem{Status: pgtype.Null}, dst: &s},
+	}
+
+	for i, tt := range errorTests {
+		err := tt.src.AssignTo(tt.dst)
+		if err == nil {
+			t.Errorf("%d: expected error but none was returned (%v -> %v)", i, tt.src, tt.dst)
+		}
+	}
+}

aclitemarray.go

@@ -0,0 +1,186 @@
+package pgtype
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+
+	"github.com/jackc/pgx/pgio"
+)
+
+type ACLItemArray struct {
+	Elements   []ACLItem
+	Dimensions []ArrayDimension
+	Status     Status
+}
+
+func (dst *ACLItemArray) ConvertFrom(src interface{}) error {
+	switch value := src.(type) {
+	case ACLItemArray:
+		*dst = value
+
+	case []string:
+		if value == nil {
+			*dst = ACLItemArray{Status: Null}
+		} else if len(value) == 0 {
+			*dst = ACLItemArray{Status: Present}
+		} else {
+			elements := make([]ACLItem, len(value))
+			for i := range value {
+				if err := elements[i].ConvertFrom(value[i]); err != nil {
+					return err
+				}
+			}
+			*dst = ACLItemArray{
+				Elements:   elements,
+				Dimensions: []ArrayDimension{{Length: int32(len(elements)), LowerBound: 1}},
+				Status:     Present,
+			}
+		}
+
+	default:
+		if originalSrc, ok := underlyingSliceType(src); ok {
+			return dst.ConvertFrom(originalSrc)
+		}
+		return fmt.Errorf("cannot convert %v to ACLItem", value)
+	}
+
+	return nil
+}
+
+func (src *ACLItemArray) AssignTo(dst interface{}) error {
+	switch v := dst.(type) {
+
+	case *[]string:
+		if src.Status == Present {
+			*v = make([]string, len(src.Elements))
+			for i := range src.Elements {
+				if err := src.Elements[i].AssignTo(&((*v)[i])); err != nil {
+					return err
+				}
+			}
+		} else {
+			*v = nil
+		}
+
+	default:
+		if originalDst, ok := underlyingPtrSliceType(dst); ok {
+			return src.AssignTo(originalDst)
+		}
+		return fmt.Errorf("cannot decode %v into %T", src, dst)
+	}
+
+	return nil
+}
+
+func (dst *ACLItemArray) DecodeText(src []byte) error {
+	if src == nil {
+		*dst = ACLItemArray{Status: Null}
+		return nil
+	}
+
+	uta, err := ParseUntypedTextArray(string(src))
+	if err != nil {
+		return err
+	}
+
+	var elements []ACLItem
+
+	if len(uta.Elements) > 0 {
+		elements = make([]ACLItem, len(uta.Elements))
+
+		for i, s := range uta.Elements {
+			var elem ACLItem
+			var elemSrc []byte
+			if s != "NULL" {
+				elemSrc = []byte(s)
+			}
+			err = elem.DecodeText(elemSrc)
+			if err != nil {
+				return err
+			}
+
+			elements[i] = elem
+		}
+	}
+
+	*dst = ACLItemArray{Elements: elements, Dimensions: uta.Dimensions, Status: Present}
+
+	return nil
+}
+
+func (src *ACLItemArray) EncodeText(w io.Writer) (bool, error) {
+	switch src.Status {
+	case Null:
+		return true, nil
+	case Undefined:
+		return false, errUndefined
+	}
+
+	if len(src.Dimensions) == 0 {
+		_, err := io.WriteString(w, "{}")
+		return false, err
+	}
+
+	err := EncodeTextArrayDimensions(w, src.Dimensions)
+	if err != nil {
+		return false, err
+	}
+
+	// dimElemCounts is the multiples of elements that each array lies on. For
+	// example, a single dimension array of length 4 would have a dimElemCounts of
+	// [4]. A multi-dimensional array of lengths [3,5,2] would have a
+	// dimElemCounts of [30,10,2]. This is used to simplify when to render a '{'
+	// or '}'.
+	dimElemCounts := make([]int, len(src.Dimensions))
+	dimElemCounts[len(src.Dimensions)-1] = int(src.Dimensions[len(src.Dimensions)-1].Length)
+	for i := len(src.Dimensions) - 2; i > -1; i-- {
+		dimElemCounts[i] = int(src.Dimensions[i].Length) * dimElemCounts[i+1]
+	}
+
+	for i, elem := range src.Elements {
+		if i > 0 {
+			err = pgio.WriteByte(w, ',')
+			if err != nil {
+				return false, err
+			}
+		}
+
+		for _, dec := range dimElemCounts {
+			if i%dec == 0 {
+				err = pgio.WriteByte(w, '{')
+				if err != nil {
+					return false, err
+				}
+			}
+		}
+
+		elemBuf := &bytes.Buffer{}
+		null, err := elem.EncodeText(elemBuf)
+		if err != nil {
+			return false, err
+		}
+		if null {
+			_, err = io.WriteString(w, `NULL`)
+			if err != nil {
+				return false, err
+			}
+		} else {
+			_, err = io.WriteString(w, QuoteArrayElementIfNeeded(elemBuf.String()))
+			if err != nil {
+				return false, err
+			}
+		}
+
+		for _, dec := range dimElemCounts {
+			if (i+1)%dec == 0 {
+				err = pgio.WriteByte(w, '}')
+				if err != nil {
+					return false, err
+				}
+			}
+		}
+	}
+
+	return false, nil
+}

aclitemarray_test.go

@@ -0,0 +1,151 @@
+package pgtype_test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/jackc/pgx/pgtype"
+)
+
+func TestACLItemArrayTranscode(t *testing.T) {
+	testSuccessfulTranscode(t, "aclitem[]", []interface{}{
+		&pgtype.ACLItemArray{
+			Elements:   nil,
+			Dimensions: nil,
+			Status:     pgtype.Present,
+		},
+		&pgtype.ACLItemArray{
+			Elements: []pgtype.ACLItem{
+				pgtype.ACLItem{String: "=r/postgres", Status: pgtype.Present},
+				pgtype.ACLItem{Status: pgtype.Null},
+			},
+			Dimensions: []pgtype.ArrayDimension{{Length: 2, LowerBound: 1}},
+			Status:     pgtype.Present,
+		},
+		&pgtype.ACLItemArray{Status: pgtype.Null},
+		&pgtype.ACLItemArray{
+			Elements: []pgtype.ACLItem{
+				pgtype.ACLItem{String: "=r/postgres", Status: pgtype.Present},
+				pgtype.ACLItem{String: "postgres=arwdDxt/postgres", Status: pgtype.Present},
+				pgtype.ACLItem{String: `postgres=arwdDxt/" tricky, ' } "" \ test user "`, Status: pgtype.Present},
+				pgtype.ACLItem{String: "=r/postgres", Status: pgtype.Present},
+				pgtype.ACLItem{Status: pgtype.Null},
+				pgtype.ACLItem{String: "=r/postgres", Status: pgtype.Present},
+			},
+			Dimensions: []pgtype.ArrayDimension{{Length: 3, LowerBound: 1}, {Length: 2, LowerBound: 1}},
+			Status:     pgtype.Present,
+		},
+		&pgtype.ACLItemArray{
+			Elements: []pgtype.ACLItem{
+				pgtype.ACLItem{String: "=r/postgres", Status: pgtype.Present},
+				pgtype.ACLItem{String: "postgres=arwdDxt/postgres", Status: pgtype.Present},
+				pgtype.ACLItem{String: "=r/postgres", Status: pgtype.Present},
+				pgtype.ACLItem{String: "postgres=arwdDxt/postgres", Status: pgtype.Present},
+			},
+			Dimensions: []pgtype.ArrayDimension{
+				{Length: 2, LowerBound: 4},
+				{Length: 2, LowerBound: 2},
+			},
+			Status: pgtype.Present,
+		},
+	})
+}
+
+func TestACLItemArrayConvertFrom(t *testing.T) {
+	successfulTests := []struct {
+		source interface{}
+		result pgtype.ACLItemArray
+	}{
+		{
+			source: []string{"=r/postgres"},
+			result: pgtype.ACLItemArray{
+				Elements:   []pgtype.ACLItem{{String: "=r/postgres", Status: pgtype.Present}},
+				Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}},
+				Status:     pgtype.Present},
+		},
+		{
+			source: (([]string)(nil)),
+			result: pgtype.ACLItemArray{Status: pgtype.Null},
+		},
+	}
+
+	for i, tt := range successfulTests {
+		var r pgtype.ACLItemArray
+		err := r.ConvertFrom(tt.source)
+		if err != nil {
+			t.Errorf("%d: %v", i, err)
+		}
+
+		if !reflect.DeepEqual(r, tt.result) {
+			t.Errorf("%d: expected %v to convert to %v, but it was %v", i, tt.source, tt.result, r)
+		}
+	}
+}
+
+func TestACLItemArrayAssignTo(t *testing.T) {
+	var stringSlice []string
+	type _stringSlice []string
+	var namedStringSlice _stringSlice
+
+	simpleTests := []struct {
+		src      pgtype.ACLItemArray
+		dst      interface{}
+		expected interface{}
+	}{
+		{
+			src: pgtype.ACLItemArray{
+				Elements:   []pgtype.ACLItem{{String: "=r/postgres", Status: pgtype.Present}},
+				Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}},
+				Status:     pgtype.Present,
+			},
+			dst:      &stringSlice,
+			expected: []string{"=r/postgres"},
+		},
+		{
+			src: pgtype.ACLItemArray{
+				Elements:   []pgtype.ACLItem{{String: "=r/postgres", Status: pgtype.Present}},
+				Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}},
+				Status:     pgtype.Present,
+			},
+			dst:      &namedStringSlice,
+			expected: _stringSlice{"=r/postgres"},
+		},
+		{
+			src:      pgtype.ACLItemArray{Status: pgtype.Null},
+			dst:      &stringSlice,
+			expected: (([]string)(nil)),
+		},
+	}
+
+	for i, tt := range simpleTests {
+		err := tt.src.AssignTo(tt.dst)
+		if err != nil {
+			t.Errorf("%d: %v", i, err)
+		}
+
+		if dst := reflect.ValueOf(tt.dst).Elem().Interface(); !reflect.DeepEqual(dst, tt.expected) {
+			t.Errorf("%d: expected %v to assign %v, but result was %v", i, tt.src, tt.expected, dst)
+		}
+	}
+
+	errorTests := []struct {
+		src pgtype.ACLItemArray
+		dst interface{}
+	}{
+		{
+			src: pgtype.ACLItemArray{
+				Elements:   []pgtype.ACLItem{{Status: pgtype.Null}},
+				Dimensions: []pgtype.ArrayDimension{{LowerBound: 1, Length: 1}},
+				Status:     pgtype.Present,
+			},
+			dst: &stringSlice,
+		},
+	}
+
+	for i, tt := range errorTests {
+		err := tt.src.AssignTo(tt.dst)
+		if err == nil {
+			t.Errorf("%d: expected error but none was returned (%v -> %v)", i, tt.src, tt.dst)
+		}
+	}
+}

pgtype.go

@@ -35,8 +35,8 @@ const (
 	Int8ArrayOID        = 1016
 	Float4ArrayOID      = 1021
 	Float8ArrayOID      = 1022
-	AclItemOID          = 1033
+	ACLItemOID          = 1033
-	AclItemArrayOID     = 1034
+	ACLItemArrayOID     = 1034
 	InetArrayOID        = 1041
 	VarcharOID          = 1043
 	DateOID             = 1082

typed_array_gen.sh

@@ -10,3 +10,4 @@ erb pgtype_array_type=Float8Array pgtype_element_type=Float8 go_array_types=[]fl
 erb pgtype_array_type=InetArray pgtype_element_type=Inet go_array_types=[]*net.IPNet,[]net.IP element_oid=InetOID text_null=NULL typed_array.go.erb > inetarray.go
 erb pgtype_array_type=TextArray pgtype_element_type=Text go_array_types=[]string element_oid=TextOID text_null='"NULL"' typed_array.go.erb > textarray.go
 erb pgtype_array_type=ByteaArray pgtype_element_type=Bytea go_array_types=[][]byte element_oid=ByteaOID text_null=NULL typed_array.go.erb > byteaarray.go
+erb pgtype_array_type=ACLItemArray pgtype_element_type=ACLItem go_array_types=[]string element_oid=ACLItemOID text_null=NULL typed_array.go.erb > aclitemarray.go