begin v1 refactoring

Author: ungerik

impl/arrays.go

@@ -2,21 +2,31 @@ package impl
 
 import (
 	"database/sql"
-	"database/sql/driver"
 	"reflect"
 
 	"github.com/lib/pq"
 )
 
-func WrapForArray(a interface{}) interface {
-	driver.Valuer
-	sql.Scanner
-} {
+// func WrapForArray(a any) interface {
+// 	driver.Valuer
+// 	sql.Scanner
+// } {
+// 	return pq.Array(a)
+// }
+
+func WrapForArrayScanning(a any) sql.Scanner {
 	return pq.Array(a)
 }
 
-func ShouldWrapForArray(v reflect.Value) bool {
+func ShouldWrapForArrayScanning(v reflect.Value) bool {
 	t := v.Type()
+	if t.Implements(typeOfSQLScanner) {
+		return false
+	}
+	if t.Kind() == reflect.Ptr && !v.IsNil() {
+		v = v.Elem()
+		t = v.Type()
+	}
 	switch t.Kind() {
 	case reflect.Slice:
 		if t.Elem() == typeOfByte {
@@ -29,6 +39,45 @@ func ShouldWrapForArray(v reflect.Value) bool {
 	return false
 }
 
+// IsNonDriverValuerSliceOrArray returns true if passed type
+// does not implement driver.Valuer and is a slice or array,
+// or a pointer to a slice or array and in case of a slice
+// not of type []byte.
+func IsNonDriverValuerSliceOrArray(t reflect.Type) bool {
+	if t == nil || t.Implements(typeOfDriverValuer) {
+		return false
+	}
+	k := t.Kind()
+	if k == reflect.Ptr {
+		t = t.Elem()
+		k = t.Kind()
+	}
+	return k == reflect.Slice && t != typeOfByteSlice || k == reflect.Array
+}
+
+// func FormatArrays(args []any) []any {
+// 	var wrappedArgs []any
+// 	for i, arg := range args {
+// 		if ShouldFormatArray(arg) {
+// 			if wrappedArgs == nil {
+// 				// Allocate new slice for wrapped element
+// 				wrappedArgs = make([]any, len(args))
+// 				// Copy previous elements
+// 				for h := 0; h < i; h++ {
+// 					wrappedArgs[h] = args[h]
+// 				}
+// 			}
+// 			wrappedArgs[i], _ = pq.Array(arg).Value()
+// 		} else if wrappedArgs != nil {
+// 			wrappedArgs[i] = arg
+// 		}
+// 	}
+// 	if wrappedArgs != nil {
+// 		return wrappedArgs
+// 	}
+// 	return args
+// }
+
 // type ArrayScanner struct {
 // 	Dest reflect.Value
 // }

impl/arrays_test.go

@@ -2,14 +2,17 @@ package impl
 
 import (
 	"database/sql"
+	"database/sql/driver"
 	"encoding/json"
 	"reflect"
 	"testing"
 
 	"github.com/domonda/go-types/nullable"
+	"github.com/lib/pq"
+	"github.com/stretchr/testify/assert"
 )
 
-func TestShouldWrapForArray(t *testing.T) {
+func TestShouldWrapForArrayScanning(t *testing.T) {
 	tests := []struct {
 		v    reflect.Value
 		want bool
@@ -21,14 +24,66 @@ func TestShouldWrapForArray(t *testing.T) {
 		{v: reflect.ValueOf(json.RawMessage([]byte("null"))), want: false},
 		{v: reflect.ValueOf(nullable.JSON([]byte("null"))), want: false},
 		{v: reflect.ValueOf(new(sql.NullInt64)).Elem(), want: false},
+		{v: reflect.ValueOf(WrapForArrayScanning([]int{0, 1})), want: false},
 
 		{v: reflect.ValueOf(new([3]string)).Elem(), want: true},
 		{v: reflect.ValueOf(new([]string)).Elem(), want: true},
 		{v: reflect.ValueOf(new([]sql.NullString)).Elem(), want: true},
 	}
 	for _, tt := range tests {
-		if got := ShouldWrapForArray(tt.v); got != tt.want {
-			t.Errorf("shouldWrapArray() = %v, want %v", got, tt.want)
-		}
+		got := ShouldWrapForArrayScanning(tt.v)
+		assert.Equal(t, tt.want, got)
 	}
 }
+
+func TestIsNonDriverValuerSliceOrArray(t *testing.T) {
+	tests := []struct {
+		t    reflect.Type
+		want bool
+	}{
+		{t: reflect.TypeOf(nil), want: false},
+		{t: reflect.TypeOf(0), want: false},
+		{t: reflect.TypeOf(new(int)), want: false},
+		{t: reflect.TypeOf("string"), want: false},
+		{t: reflect.TypeOf([]byte("string")), want: false},
+		{t: reflect.TypeOf(new([]byte)), want: false},
+		{t: reflect.TypeOf(pq.BoolArray{true}), want: false},
+		{t: reflect.TypeOf(new(pq.BoolArray)), want: false},
+		{t: reflect.TypeOf(new(*[]int)), want: false}, // pointer to a pointer to a slice
+		{t: reflect.TypeOf((*driver.Valuer)(nil)), want: false},
+		{t: reflect.TypeOf((*driver.Valuer)(nil)).Elem(), want: false},
+
+		{t: reflect.TypeOf([3]int{1, 2, 3}), want: true},
+		{t: reflect.TypeOf((*[3]int)(nil)), want: true},
+		{t: reflect.TypeOf([]int{1, 2, 3}), want: true},
+		{t: reflect.TypeOf((*[]int)(nil)), want: true},
+		{t: reflect.TypeOf((*[][]byte)(nil)), want: true},
+	}
+	for _, tt := range tests {
+		got := IsNonDriverValuerSliceOrArray(tt.t)
+		assert.Equalf(t, tt.want, got, "IsNonDriverValuerSliceOrArray(%s)", tt.t)
+	}
+}
+
+// func TestWrapArgsForArrays(t *testing.T) {
+// 	tests := []struct {
+// 		args []any
+// 		want []any
+// 	}{
+// 		{args: nil, want: nil},
+// 		{args: []any{}, want: []any{}},
+// 		{args: []any{0}, want: []any{0}},
+// 		{args: []any{nil}, want: []any{nil}},
+// 		{args: []any{new(int)}, want: []any{new(int)}},
+// 		{args: []any{0, []int{0, 1}, "string"}, want: []any{0, wrapArgForArray([]int{0, 1}), "string"}},
+// 		{args: []any{wrapArgForArray([]int{0, 1})}, want: []any{wrapArgForArray([]int{0, 1})}},
+// 		{args: []any{[]byte("don't wrap []byte")}, want: []any{[]byte("don't wrap []byte")}},
+// 		{args: []any{pq.BoolArray{true}}, want: []any{pq.BoolArray{true}}},
+// 		{args: []any{[3]int{1, 2, 3}}, want: []any{wrapArgForArray([3]int{1, 2, 3})}},
+// 		{args: []any{wrapArgForArray([3]int{1, 2, 3})}, want: []any{wrapArgForArray([3]int{1, 2, 3})}},
+// 	}
+// 	for _, tt := range tests {
+// 		got := WrapArgsForArrays(tt.args)
+// 		assert.Equal(t, tt.want, got)
+// 	}
+// }

impl/connection.go

@@ -0,0 +1,16 @@
+package impl
+
+import (
+	"context"
+	"database/sql"
+)
+
+type Execer interface {
+	ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error)
+}
+
+func Exec(ctx context.Context, conn Execer, argFmt, query string, args []any) error {
+	// args = WrapArgsForArrays(args)
+	_, err := conn.ExecContext(ctx, query, args...)
+	return WrapNonNilErrorWithQuery(err, query, argFmt, args)
+}