port of go-sql-server-driver tests from dolt

Author: zachmu

integration-tests/go-sql-server-driver/auto_gc_test.go

@@ -0,0 +1,30 @@
+// Copyright 2024 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import "testing"
+
+// TestAutoGC is ported from Dolt's auto_gc_test.go. It exercises the server's
+// automatic garbage-collection behavior under load. Doltgres currently
+// disables automatic GC (servercfg DoltgresAutoGCBehavior.Enable() returns
+// false and there is no dolt_auto_gc_enabled / auto_gc_behavior config), so
+// this test is skipped until auto-GC is supported.
+//
+// The full test logic lives in the Dolt source at
+// integration-tests/go-sql-server-driver/auto_gc_test.go and should be ported
+// once Doltgres supports automatic GC.
+func TestAutoGC(t *testing.T) {
+	t.Skip("automatic GC is not yet implemented in Doltgres (AutoGCBehavior.Enable() == false)")
+}

integration-tests/go-sql-server-driver/clone_no_conjoin_test.go

@@ -0,0 +1,30 @@
+// Copyright 2024 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import "testing"
+
+// TestCloneNoConjoin is ported from Dolt's clone_no_conjoin_test.go. It clones
+// a database through a running sql-server and asserts the clone does not
+// trigger a conjoin of table files. This depends on Dolt's remotes/clone
+// behavior and on inspecting on-disk table-file/conjoin storage internals,
+// neither of which is available from the doltgres test driver yet (the
+// remotes API is not implemented in Doltgres).
+//
+// The full test logic lives in the Dolt source at
+// integration-tests/go-sql-server-driver/clone_no_conjoin_test.go.
+func TestCloneNoConjoin(t *testing.T) {
+	t.Skip("clone/conjoin storage internals and the remotes API are not yet supported in Doltgres")
+}

integration-tests/go-sql-server-driver/concurrent_drop_database_test.go

@@ -0,0 +1,139 @@
+// Copyright 2026 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"sync/atomic"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"golang.org/x/sync/errgroup"
+
+	driver "github.com/dolthub/doltgresql/integration-tests/go-sql-server-driver/driver"
+)
+
+// TestConcurrentDropDatabase is a regression test for #10692.
+//
+// A lock-ordering bug between *DatabaseProvider and *DoltSession meant that
+// DROP DATABASE during concurrency could cause the DatabaseProvider to
+// deadlock and the server databases to become unavailable.
+func TestConcurrentDropDatabase(t *testing.T) {
+	t.Parallel()
+	ports := newPorts(t)
+	u, err := driver.NewDoltUser()
+	require.NoError(t, err)
+	t.Cleanup(func() {
+		u.Cleanup()
+	})
+
+	rs, err := u.MakeRepoStore()
+	require.NoError(t, err)
+
+	_, err = rs.MakeRepo("concurrent_drop_database_test")
+	require.NoError(t, err)
+
+	srvSettings := &driver.Server{
+		Args:        []string{},
+		DynamicPort: "server_port",
+	}
+	server := StartServer(t, rs, "concurrent_drop_database_test", srvSettings, ports)
+
+	db, err := server.DB(driver.Connection{})
+	require.NoError(t, err)
+	db.SetMaxIdleConns(0)
+	defer func() {
+		require.NoError(t, db.Close())
+	}()
+	ctx := t.Context()
+
+	eg, ctx := errgroup.WithContext(ctx)
+	var numcreates int32 = 0
+	const numWriters = 8
+	const numDatabasesPerWriter = 12
+	startCh := make(chan struct{})
+	readyCh := make(chan struct{})
+	for i := range numWriters {
+		eg.Go(func() error {
+			conn, err := db.Conn(ctx)
+			if err != nil {
+				return err
+			}
+			defer conn.Close()
+			select {
+			case readyCh <- struct{}{}:
+			case <-ctx.Done():
+				return nil
+			}
+			select {
+			case <-startCh:
+			case <-ctx.Done():
+				return nil
+			}
+			for j := range numDatabasesPerWriter {
+				if ctx.Err() != nil {
+					return context.Cause(ctx)
+				}
+				database := fmt.Sprintf("db%08d%08d", i, j)
+				_, err := conn.ExecContext(ctx, "CREATE DATABASE "+database)
+				if err != nil {
+					return err
+				}
+				atomic.AddInt32(&numcreates, 1)
+				_, err = conn.ExecContext(ctx, "DROP DATABASE "+database)
+				if err != nil {
+					return err
+				}
+			}
+			return nil
+		})
+	}
+	for range numWriters {
+		select {
+		case <-readyCh:
+		case <-ctx.Done():
+			// This will fail.
+			require.NoError(t, eg.Wait())
+			t.FailNow()
+		}
+	}
+	close(startCh)
+	require.NoError(t, eg.Wait())
+	ctx = t.Context()
+	conn, err := db.Conn(ctx)
+	require.NoError(t, err)
+	defer conn.Close()
+	rows, err := conn.QueryContext(ctx, "SELECT datname FROM pg_database")
+	require.NoError(t, err)
+	defer rows.Close()
+	var databases []string
+	for rows.Next() {
+		var db string
+		err = rows.Scan(&db)
+		require.NoError(t, err)
+		databases = append(databases, db)
+	}
+	require.NoError(t, rows.Err())
+	// The provider must still be functional, and none of the created-and-dropped
+	// databases should remain. The test database must still be present.
+	require.Contains(t, databases, "concurrent_drop_database_test")
+	for _, name := range databases {
+		require.False(t, strings.HasPrefix(name, "db0000"),
+			"created-and-dropped database %q should not remain", name)
+	}
+	t.Logf("created and dropped %d databases", numcreates)
+}