Add support for NamedValueChecker interface

Added in 1.9: https://go.dev/doc/go1.9#minor_library_changes.

array.go

@@ -19,10 +19,11 @@ var typeSQLScanner = reflect.TypeOf((*sql.Scanner)(nil)).Elem()
 // slice of any dimension.
 //
 // For example:
-//  db.Query(`SELECT * FROM t WHERE id = ANY($1)`, pq.Array([]int{235, 401}))
 //
-//  var x []sql.NullInt64
-//  db.QueryRow(`SELECT ARRAY[235, 401]`).Scan(pq.Array(&x))
+//	db.Query(`SELECT * FROM t WHERE id = ANY($1)`, pq.Array([]int{235, 401}))
+//
+//	var x []sql.NullInt64
+//	db.QueryRow(`SELECT ARRAY[235, 401]`).Scan(pq.Array(&x))
 //
 // Scanning multi-dimensional arrays is not supported.  Arrays where the lower
 // bound is not one (such as `[0:0]={1}') are not supported.

conn_go19.go

@@ -0,0 +1,35 @@
+//go:build go1.9
+// +build go1.9
+
+package pq
+
+import (
+	"database/sql/driver"
+	"reflect"
+)
+
+var _ driver.NamedValueChecker = (*conn)(nil)
+
+func (c *conn) CheckNamedValue(nv *driver.NamedValue) error {
+	if _, ok := nv.Value.(driver.Valuer); ok {
+		// Ignore Valuer, for backward compatiblity with pq.Array()
+		return driver.ErrSkip
+	}
+
+	// Ignoring []byte / []uint8
+	if _, ok := nv.Value.([]uint8); ok {
+		return driver.ErrSkip
+	}
+
+	v := reflect.ValueOf(nv.Value)
+	if v.Kind() == reflect.Ptr {
+		v = v.Elem()
+	}
+	if v.Kind() == reflect.Slice {
+		var err error
+		nv.Value, err = Array(nv.Value).Value()
+		return err
+	}
+
+	return driver.ErrSkip
+}

conn_go19_test.go

@@ -0,0 +1,61 @@
+//go:build go1.9
+// +build go1.9
+
+package pq
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestArrayArg(t *testing.T) {
+	db := openTestConn(t)
+	defer db.Close()
+
+	for _, want := range []interface{}{
+		[]int{245, 231},
+		[]int64{245, 231},
+	} {
+		for _, want := range []interface{}{want, &want} {
+			rt := reflect.TypeOf(want)
+			t.Run(rt.Name(), func(t *testing.T) {
+				r, err := db.Query("SELECT $1::int[]", want)
+				if err != nil {
+					t.Fatal(err)
+				}
+				defer r.Close()
+
+				if !r.Next() {
+					if r.Err() != nil {
+						t.Fatal(r.Err())
+					}
+					t.Fatal("expected row")
+				}
+
+				defer func() {
+					if r.Next() {
+						t.Fatal("unexpected row")
+					}
+				}()
+
+				rt := reflect.TypeOf(want)
+				wantPtr := rt.Kind() == reflect.Ptr
+				if wantPtr {
+					rt = rt.Elem()
+				}
+				got := reflect.New(rt)
+				if err := r.Scan(Array(got.Interface())); err != nil {
+					t.Fatal(err)
+				}
+				if !wantPtr {
+					got = got.Elem()
+				}
+
+				if !reflect.DeepEqual(want, got.Interface()) {
+					t.Errorf("got %v, want %v", got, want)
+				}
+			})
+		}
+	}
+
+}