Test CockroachDB

Author: arp242

.github/workflows/test.yml

@@ -74,6 +74,27 @@ jobs:
         echo PGPORT=6432 'PQTEST_BINARY_PARAMETERS=yes go test -race ./...'
         PGPORT=6432 PQTEST_BINARY_PARAMETERS=yes go test -race ./...
 
+  cockroach:
+    runs-on: 'ubuntu-latest'
+    steps:
+    - uses: 'actions/checkout@v6'
+    - uses: 'actions/setup-go@v6'
+      with: {go-version: '1.26'}
+    - name: 'Start CockroachDB'
+      run: |
+        docker compose up cockroach -d --wait || {
+          docker compose logs
+          exit 1
+        }
+        echo '127.0.0.1 postgres postgres-invalid' | sudo tee -a /etc/hosts
+    - name: 'Run tests'
+      run: |
+        echo 'PGPORT=26257 PQTEST_BINARY_PARAMETERS=no  go test -race -skip='^Example' ./...'
+        PGPORT=26257 PQTEST_BINARY_PARAMETERS=no  go test -race -skip='^Example' ./...
+
+        echo PGPORT=26257 'PQTEST_BINARY_PARAMETERS=yes go test -race -skip='^Example' ./...'
+        PGPORT=26257 PQTEST_BINARY_PARAMETERS=yes go test -race -skip='^Example' ./...
+
   # Disabled for now as it's kind of finecky and flaky.
   #pgpool:
   #  runs-on: 'ubuntu-latest'

compose.yaml

@@ -20,6 +20,14 @@ services:
       'PGPOOL_PARAMS_PORT':              '7432'
       'PGPOOL_PARAMS_BACKEND_HOSTNAME0': 'pg18'
 
+  cockroach:
+    profiles:    ['cockroach']
+    image:       'cockroachdb/cockroach:latest-v26.1'
+    ports:       ['127.0.0.1:26257:26257']
+    volumes:     ['./testdata/cockroach:/docker-entrypoint-initdb.d', './testdata/ssl:/ssl']
+    command:     ['start-single-node', '--accept-sql-without-tls', '--certs-dir=/ssl2']
+    healthcheck: {test: ['CMD-SHELL', '/cockroach/cockroach node status --insecure --user=pqgo'], start_period: '30s', start_interval: '1s'}
+
   pg18:
     image:       'postgres:18'
     ports:       ['127.0.0.1:5432:5432']

conn_test.go

@@ -28,6 +28,7 @@ import (
 )
 
 func TestReconnect(t *testing.T) {
+	pqtest.SkipCockroach(t) // Doesn't implement pg_terminate_backend()
 	t.Parallel()
 	db := pqtest.MustDB(t)
 	tx := pqtest.Begin(t, db)
@@ -655,6 +656,7 @@ func TestErrorOnQueryRowSimpleQuery(t *testing.T) {
 
 // Test the QueryRow bug workarounds in stmt.exec() and simpleQuery()
 func TestQueryRowBugWorkaround(t *testing.T) {
+	pqtest.SkipCockroach(t) // check_function_bodies=false doesn't really work
 	db := pqtest.MustDB(t)
 
 	pqtest.Exec(t, db, "create temp table notnulltemp (a varchar(10) not null)")
@@ -805,7 +807,7 @@ func TestExecNoData(t *testing.T) { // See #186
 
 	// Exec() a query which returns results
 	pqtest.Exec(t, db, "values (1), (2), (3)")
-	pqtest.Exec(t, db, "values ($1), ($2), ($3)", 1, 2, 3)
+	pqtest.Exec(t, db, "values ($1::int), ($2::int), ($3::int)", 1, 2, 3)
 
 	// Query() a query which doesn't return any results
 	tx := pqtest.Begin(t, db)
@@ -816,11 +818,13 @@ func TestExecNoData(t *testing.T) { // See #186
 		t.Errorf("\nhave: %#v\nwant: %#v", have, want)
 	}
 
-	// Get NoData from a parameterized query.
-	pqtest.Exec(t, tx, `create rule nodata as on insert to foo do instead nothing`)
-	have = pqtest.QueryRow[any](t, tx, `insert into foo values ($1)`, 1)
-	if !reflect.DeepEqual(have, want) {
-		t.Errorf("\nhave: %#v\nwant: %#v", have, want)
+	if !pqtest.Cockroach() { // "unimplemented: this syntax (0A000)"
+		// Get NoData from a parameterized query.
+		pqtest.Exec(t, tx, `create rule nodata as on insert to foo do instead nothing`)
+		have = pqtest.QueryRow[any](t, tx, `insert into foo values ($1)`, 1)
+		if !reflect.DeepEqual(have, want) {
+			t.Errorf("\nhave: %#v\nwant: %#v", have, want)
+		}
 	}
 }
 
@@ -841,11 +845,18 @@ func TestIssue282(t *testing.T) {
 }
 
 func TestFloatPrecision(t *testing.T) { // See #196
+	// encode() sends float32 as a float64, which adds extra precision: 0.10000122338533401
+	// This is done by driver.DefaultParameterConverter(); we can maybe fix it,
+	// but it's really a cockroach bug.
+	// https://github.com/cockroachdb/cockroach/issues/73743
+	// https://github.com/cockroachdb/cockroach/issues/84326
+	pqtest.SkipCockroach(t)
+
 	t.Parallel()
 	db := pqtest.MustDB(t)
 
-	have := pqtest.Query[bool](t, db, `select '0.10000122'::float4 = $1 as f4, '35.03554004971999'::float8 = $2 as f8`,
-		float32(0.10000122), float64(35.03554004971999))[0]
+	have := pqtest.QueryRow[bool](t, db, `select '0.10000122'::float4 = $1::float4 as f4, '35.03554004971999'::float8 = $2 as f8`,
+		float32(0.10000122), float64(35.03554004971999))
 	want := map[string]bool{"f4": true, "f8": true}
 	if !reflect.DeepEqual(have, want) {
 		t.Errorf("\nhave: %#v\nwant: %#v", have, want)
@@ -1106,7 +1117,7 @@ func TestStmtQueryContext(t *testing.T) {
 			func() (context.Context, context.CancelFunc) {
 				return context.WithTimeout(context.Background(), 50*time.Millisecond)
 			},
-			`pq: canceling statement due to user request (57014)`,
+			`or:pq: canceling statement due to user request (57014)|pq: query execution canceled (57014)`,
 		},
 		{"select pg_sleep(0.05)",
 			func() (context.Context, context.CancelFunc) {
@@ -1150,7 +1161,7 @@ func TestStmtExecContext(t *testing.T) {
 			func() (context.Context, context.CancelFunc) {
 				return context.WithTimeout(context.Background(), 50*time.Millisecond)
 			},
-			`pq: canceling statement due to user request (57014)`,
+			`or:pq: canceling statement due to user request (57014)|pq: query execution canceled (57014)`,
 		},
 		{"select pg_sleep(0.05)",
 			func() (context.Context, context.CancelFunc) {
@@ -1361,6 +1372,12 @@ func TestTxOptions(t *testing.T) {
 	// go18_test.go:306: read/[write,only] not set: true != off for level serializable
 	// go18_test.go:296: wrong isolation level: read committed != serializable
 	pqtest.SkipPgpool(t)
+	// TODO: fails with:
+	// conn_test.go:1724: wrong isolation level: read committed != read uncommitted
+	// conn_test.go:1724: wrong isolation level: read committed != read uncommitted
+	// conn_test.go:1724: wrong isolation level: serializable != repeatable read
+	// conn_test.go:1724: wrong isolation level: serializable != repeatable read
+	pqtest.SkipCockroach(t)
 
 	db := pqtest.MustDB(t)
 	ctx := context.Background()
@@ -1424,7 +1441,8 @@ func TestTxOptions(t *testing.T) {
 
 func TestPing(t *testing.T) {
 	t.Parallel()
-	pqtest.SkipPgpool(t) // TODO: hangs forever?
+	pqtest.SkipPgpool(t)    // TODO: hangs forever?
+	pqtest.SkipCockroach(t) // Doesn't implement pg_terminate_backend()
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
@@ -1534,19 +1552,19 @@ func TestAuth(t *testing.T) {
 		tests := []struct {
 			conn, wantErr string
 		}{
-			{"user=pqgomd5", `password authentication failed for user "pqgomd5"`},
-			{"user=pqgopassword", `empty password returned by client`},
-			{"user=pqgoscram", `password authentication failed for user "pqgoscram"`},
+			{"user=pqgomd5", `re:password authentication failed for user "?pqgomd5"?`},
+			{"user=pqgopassword", `or:empty password returned by client|password authentication failed for user pqgopassword`},
+			{"user=pqgoscram", `re:password authentication failed for user "?pqgoscram"?`},
 
-			{"user=pqgomd5 password=wrong", `password authentication failed for user "pqgomd5"`},
-			{"user=pqgopassword password=wrong", `password authentication failed for user "pqgopassword"`},
-			{"user=pqgoscram    password=wrong", `password authentication failed for user "pqgoscram"`},
+			{"user=pqgomd5 password=wrong", `re:password authentication failed for user "?pqgomd5"?`},
+			{"user=pqgopassword password=wrong", `re:password authentication failed for user "?pqgopassword"?`},
+			{"user=pqgoscram    password=wrong", `re:password authentication failed for user "?pqgoscram"?`},
 
 			{"user=pqgomd5 password=wordpass", ``},
 			{"user=pqgopassword password=wordpass", ``},
 			{"user=pqgoscram password=wordpass", ``},
 
-			{"user=pqgounknown password=wordpass", `role "pqgounknown" does not exist`},
+			{"user=pqgounknown password=wordpass", `or:role "pqgounknown" does not exist|password authentication failed for user pqgounknown`},
 		}
 
 		for _, tt := range tests {
@@ -1603,6 +1621,10 @@ func TestBytea(t *testing.T) {
 }
 
 func TestJSONRawMessage(t *testing.T) {
+	if pqtest.ForceBinaryParameters() {
+		// "expected JSONB version 1 (08P01)" – looks like it always expects jsonb (instead of json)?
+		pqtest.SkipCockroach(t) // TODO: can probably fix
+	}
 	db := pqtest.MustDB(t)
 
 	pqtest.Exec(t, db, `create temp table tbl (j json)`)
@@ -1611,10 +1633,11 @@ func TestJSONRawMessage(t *testing.T) {
 	// not converted to a PostgreSQL array. This was a bug in CheckNamedValue
 	// where named byte slice types would hit the reflect.Slice case and get
 	// incorrectly converted to a PostgreSQL array.
-	data := json.RawMessage(`{"key":"value"}`)
+	data := json.RawMessage(`{"key": "value"}`)
 	pqtest.Exec(t, db, `insert into tbl values ($1)`, data)
 
 	have := pqtest.QueryRow[json.RawMessage](t, db, `select j from tbl`)
+	have["j"] = bytes.ReplaceAll(have["j"], []byte(`":"`), []byte(`": "`)) // Cockroach adds a space
 	want := map[string]json.RawMessage{"j": data}
 	if !reflect.DeepEqual(have, want) {
 		t.Errorf("\nhave: %#v\nwant: %#v", have, want)

connector_test.go

@@ -115,6 +115,11 @@ func TestNewConnector(t *testing.T) {
 	})
 
 	t.Run("database=", func(t *testing.T) {
+		// Cockroach allows connecting to any database name, although it does
+		// give an error on DDL statements (but not "select;" / Ping()). Pretty
+		// weird, but not really important to run this test there so whatever.
+		pqtest.SkipCockroach(t)
+
 		want1, want2 := `or:pq: database "err" does not exist (3D000)|pq: no such database: err (08P01)`,
 			`or:pq: database "two" does not exist (3D000)|pq: no such database: two (08P01)`
 
@@ -194,34 +199,36 @@ func TestRuntimeParameters(t *testing.T) {
 		want          string
 		wantErr       string
 		skipPgbouncer bool
+		skipCockroach bool
 	}{
-		{"DOESNOTEXIST=foo", "", "", `or:unrecognized configuration parameter|unsupported startup parameter`, false},
+		// cockroach does not error on unknown config options.
+		{"DOESNOTEXIST=foo", "", "", `or:unrecognized configuration parameter|unsupported startup parameter`, false, true},
 
 		// we can only work with a specific value for these two
-		{"client_encoding=SQL_ASCII", "", "", `unsupported client_encoding "SQL_ASCII": must be absent or "UTF8"`, false},
-		{"datestyle='ISO, YDM'", "", "", `unsupported datestyle "ISO, YDM": must be absent or "ISO, MDY"`, false},
+		{"client_encoding=SQL_ASCII", "", "", `unsupported client_encoding "SQL_ASCII": must be absent or "UTF8"`, false, false},
+		{"datestyle='ISO, YDM'", "", "", `unsupported datestyle "ISO, YDM": must be absent or "ISO, MDY"`, false, false},
 
 		// "options" should work exactly as it does in libpq
 		// Skipped on pgbouncer as it errors with:
 		//   pq: unsupported startup parameter in options: search_path
-		{"options='-c search_path=pqgotest'", "search_path", "pqgotest", "", true},
+		{"options='-c search_path=pqgotest'", "search_path", "pqgotest", "", true, false},
 
 		// pq should override client_encoding in this case
 		// TODO: not set consistently with pgbouncer
-		{"options='-c client_encoding=SQL_ASCII'", "client_encoding", "UTF8", "", true},
+		{"options='-c client_encoding=SQL_ASCII'", "client_encoding", "UTF8", "", true, false},
 
 		// allow client_encoding to be set explicitly
-		{"client_encoding=UTF8", "client_encoding", "UTF8", "", false},
+		{"client_encoding=UTF8", "client_encoding", "UTF8", "", false, false},
 
 		// test a runtime parameter not supported by libpq
 		// Skipped on pgbouncer as it errors with:
-		//   pq: unsupported startup parameter: work_mem
-		{"work_mem='139kB'", "work_mem", "139kB", "", true},
+		//   pq: unsupported startup parameter: search_path (08P01)
+		{"search_path='a, b'", "search_path", "a, b", "", true, false},
 
 		// test fallback_application_name
-		{"application_name=foo fallback_application_name=bar", "application_name", "foo", "", false},
-		{"application_name='' fallback_application_name=bar", "application_name", "", "", false},
-		{"fallback_application_name=bar", "application_name", "bar", "", false},
+		{"application_name=foo fallback_application_name=bar", "application_name", "foo", "", false, false},
+		{"application_name='' fallback_application_name=bar", "application_name", "", "", false, false},
+		{"fallback_application_name=bar", "application_name", "bar", "", false, false},
 	}
 
 	pqtest.Unsetenv(t, "PGAPPNAME")
@@ -230,6 +237,9 @@ func TestRuntimeParameters(t *testing.T) {
 			if tt.skipPgbouncer {
 				pqtest.SkipPgbouncer(t)
 			}
+			if tt.skipCockroach {
+				pqtest.SkipCockroach(t)
+			}
 
 			db, err := pqtest.DB(t, tt.conninfo)
 			if !pqtest.ErrorContains(err, tt.wantErr) {

copy.go

@@ -6,6 +6,7 @@ import (
 	"encoding/binary"
 	"errors"
 	"fmt"
+	"os"
 	"sync"
 
 	"github.com/lib/pq/internal/proto"
@@ -121,9 +122,10 @@ func (ci *copyin) flush(buf []byte) error {
 	if len(buf)-1 > proto.MaxUint32 {
 		return errors.New("pq: too many columns")
 	}
-	// set message length (without message identifier)
-	binary.BigEndian.PutUint32(buf[1:], uint32(len(buf)-1))
-
+	if debugProto {
+		fmt.Fprintf(os.Stderr, "CLIENT → %-20s %5d  %q\n", proto.RequestCode(buf[0]), len(buf)-5, buf[5:])
+	}
+	binary.BigEndian.PutUint32(buf[1:], uint32(len(buf)-1)) // Set message length (without message identifier).
 	_, err := ci.cn.c.Write(buf)
 	return err
 }

copy_test.go

@@ -21,7 +21,7 @@ func TestCopyInError(t *testing.T) {
 	}{
 		{`copy tbl (num) from stdin with binary`, `only text format supported for COPY`},
 		{"-- comment\n  /* comment */  copy tbl (num) to stdout", `COPY TO is not supported`},
-		{`copy syntax error`, `syntax error at or near "error" at column 13`},
+		{`copy syntax error`, `or:syntax error at or near "error" at column 13|at or near "error": syntax error`},
 	}
 
 	for _, tt := range tests {
@@ -164,6 +164,7 @@ func TestCopyInMultipleValues(t *testing.T) {
 }
 
 func TestCopyInRaiseStmtTrigger(t *testing.T) {
+	pqtest.SkipCockroach(t) // "unimplemented: cannot create user-defined functions under a temporary schema"
 	t.Parallel()
 	db := pqtest.MustDB(t)
 	tx := pqtest.Begin(t, db)
@@ -199,6 +200,7 @@ func TestCopyInRaiseStmtTrigger(t *testing.T) {
 }
 
 func TestCopyInTypes(t *testing.T) {
+	pqtest.SkipCockroach(t) // https://github.com/cockroachdb/cockroach/issues/167309
 	t.Parallel()
 	db := pqtest.MustDB(t)
 	tx := pqtest.Begin(t, db)
@@ -223,6 +225,8 @@ func TestCopyInTypes(t *testing.T) {
 
 // Tests for connection errors in copyin.resploop()
 func TestCopyInRespLoopConnectionError(t *testing.T) {
+	pqtest.SkipCockroach(t) // Doesn't implement pg_terminate_backend()
+
 	// Executes f in a backoff loop until it doesn't return an error. If this
 	// doesn't happen within duration, t.Fatal is called with the latest error.
 	retry := func(t *testing.T, duration time.Duration, f func() error) {

encode_test.go

@@ -51,6 +51,9 @@ func TestTimeScan(t *testing.T) {
 	t.Parallel()
 	for _, tt := range tests {
 		t.Run(tt.in, func(t *testing.T) {
+			if strings.Contains(tt.in, "Etc/") {
+				pqtest.SkipCockroach(t) // https://github.com/cockroachdb/cockroach/issues/167310
+			}
 			have := pqtest.QueryRow[time.Time](t, db, fmt.Sprintf(`select $1::%s as t`, tt.typ), tt.in)["t"]
 			if !tt.want.Equal(have) {
 				t.Errorf("\nhave: %s\nwant: %s", have, tt.want)
@@ -248,21 +251,28 @@ func TestDecodeScan(t *testing.T) {
 		wantErrBin string
 	}{
 		{`select $1::text`, []any{"hello\x00world"}, nil, `invalid byte sequence`, `X`},
+		{`select $1::text`, []any{"hello\xffworld"}, nil, `re:invalid (byte|UTF-8) sequence`, `X`},
 		{`select $1::text`, []any{[]byte("hello world")}, "hello world", ``, `X`},
 		{`select $1::bytea`, []any{[]byte("hello world")}, []byte("hello world"), ``, `X`},
 
-		{`select $1::uuid`, []any{[]byte(uuid)}, []byte(uuid), ``, `pq: incorrect binary data format in bind parameter 1 (22P03)`},
-		{`select $1::uuid`, []any{uuidb}, []byte(uuid), `invalid byte sequence`, ``},
+		{`select $1::uuid`, []any{[]byte(uuid)}, []byte(uuid), ``, `or:incorrect binary data format in bind parameter 1 (22P03)|UUID must be exactly 16 bytes long, got 36 bytes (22P02)`},
+		{`select $1::uuid`, []any{uuidb}, []byte(uuid), `or:invalid byte sequence|incorrect UUID length`, ``},
 		{`select $1::uuid`, []any{uuid}, []byte(uuid), ``, `X`},
 
 		{`select $1::int`, []any{fmt.Append(nil, 12345678)}, int64(12345678), ``, `pq: incorrect binary data format in bind parameter 1 (22P03)`},
-		{`select $1::int`, []any{[]byte{0x00, 0xbc, 0x61, 0x4e}}, int64(12345678), `invalid byte sequence`, ``},
+		{`select $1::int`, []any{[]byte{0x00, 0xbc, 0x61, 0x4e}}, int64(12345678), `or:invalid byte sequence|could not parse "\x00\xbcaN" as type int4`, ``},
 	}
 
 	t.Parallel()
 	db := pqtest.MustDB(t)
-	for _, tt := range tests {
+	for i, tt := range tests {
 		t.Run("", func(t *testing.T) {
+			if s, ok := tt.params[0].(string); ok && strings.ContainsRune(s, 0x00) {
+				pqtest.SkipCockroach(t) // https://github.com/cockroachdb/cockroach/issues/167287
+			}
+			if pqtest.ForceBinaryParameters() && i == 7 {
+				pqtest.SkipCockroach(t) // TODO: no error? Don't really follow why
+			}
 			var have any
 			err := db.QueryRow(tt.query, tt.params...).Scan(&have)
 			wantErr := tt.wantErr

error_test.go

@@ -46,6 +46,10 @@ func TestErrorClass(t *testing.T) {
 }
 
 func TestError(t *testing.T) {
+	// Many error messages are quite different in Cockroach, are missing info, etc.
+	// TODO: can probs do better than skipping it all outright.
+	pqtest.SkipCockroach(t)
+
 	tests := []struct {
 		in, want, wantDetail string
 	}{

hstore/hstore_test.go

@@ -11,6 +11,8 @@ import (
 )
 
 func TestHstore(t *testing.T) {
+	pqtest.SkipCockroach(t) // "unimplemented: extension "hstore" is not yet supported (0A000)"
+
 	tr := strings.NewReplacer("\t", "", "\n", "", `\n`, "\n", `\t`, "\t")
 	tests := []struct {
 		in   string