feat: add dialect connection property (#710)

* feat: add dialect connection property

Adds a `dialect` connection property that determines which dialect is
used for any new database that is created by this connection. This
property can also be set in combination with the `auto_config_emulator`
connection property to determine the dialect of the database that
should be created automatically on the Emulator.

* chore: address review comments

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

---------

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

Author: olavloite

conn.go

@@ -666,9 +666,13 @@ func (c *conn) execDDL(ctx context.Context, statements ...spanner.Statement) (dr
 			ddlStatements[i] = s.SQL
 		}
 		if c.parser.IsCreateDatabaseStatement(ddlStatements[0]) {
+			dialect := c.parser.Dialect
+			if d := propertyDialect.GetValueOrDefault(c.state); d != adminpb.DatabaseDialect_DATABASE_DIALECT_UNSPECIFIED {
+				dialect = d
+			}
 			op, err := c.adminClient.CreateDatabase(ctx, &adminpb.CreateDatabaseRequest{
 				CreateStatement: ddlStatements[0],
-				DatabaseDialect: c.parser.Dialect,
+				DatabaseDialect: dialect,
 				Parent:          c.instance,
 				ExtraStatements: ddlStatements[1:],
 			})

conn_with_mockserver_test.go

@@ -749,6 +749,55 @@ func TestCreateDatabase(t *testing.T) {
 	}
 }
 
+func TestCreateDatabaseWithDialect(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	db, server, teardown := setupTestDBConnection(t)
+	defer teardown()
+
+	var expectedResponse = &databasepb.Database{}
+	anyMsg, _ := anypb.New(expectedResponse)
+	server.TestDatabaseAdmin.SetResps([]proto.Message{
+		&longrunningpb.Operation{
+			Done:   true,
+			Result: &longrunningpb.Operation_Response{Response: anyMsg},
+			Name:   "test-operation",
+		},
+	})
+
+	conn, err := db.Conn(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer silentClose(conn)
+
+	if _, err := conn.ExecContext(ctx, "set dialect = 'postgresql'"); err != nil {
+		t.Fatalf("failed to set dialect: %v", err)
+	}
+	if _, err = conn.ExecContext(ctx, `create database "foo"`); err != nil {
+		t.Fatalf("failed to execute CREATE DATABASE: %v", err)
+	}
+
+	requests := server.TestDatabaseAdmin.Reqs()
+	if g, w := len(requests), 1; g != w {
+		t.Fatalf("requests count mismatch\nGot: %v\nWant: %v", g, w)
+	}
+	if req, ok := requests[0].(*databasepb.CreateDatabaseRequest); ok {
+		if g, w := req.Parent, "projects/p/instances/i"; g != w {
+			t.Fatalf("parent mismatch\n Got: %v\nWant: %v", g, w)
+		}
+		if g, w := req.CreateStatement, `create database "foo"`; g != w {
+			t.Fatalf("CREATE statement mismatch\n Got: %v\nWant: %v", g, w)
+		}
+		if g, w := req.DatabaseDialect, databasepb.DatabaseDialect_POSTGRESQL; g != w {
+			t.Fatalf("dialect mismatch\n Got: %v\nWant: %v", g, w)
+		}
+	} else {
+		t.Fatalf("request type mismatch, got %v", requests[0])
+	}
+}
+
 func TestCreateDatabaseWithExtraStatements(t *testing.T) {
 	t.Parallel()
 

connection_properties.go

@@ -21,6 +21,7 @@ import (
 	"time"
 
 	"cloud.google.com/go/spanner"
+	"cloud.google.com/go/spanner/admin/database/apiv1/databasepb"
 	"cloud.google.com/go/spanner/apiv1/spannerpb"
 	"github.com/googleapis/go-sql-spanner/connectionstate"
 	"github.com/googleapis/go-sql-spanner/parser"
@@ -65,6 +66,20 @@ var propertyConnectionStateType = createConnectionProperty(
 		return parseConnectionStateType(value)
 	},
 )
+var propertyDialect = createConnectionProperty(
+	"dialect",
+	"The default dialect to use when creating new databases using this connection. "+
+		"You do not need to set this property for any existing database. The driver will "+
+		"automatically detect the dialect of the database that you connect to. The value of "+
+		"this property is only used when the connection is used to create a new database. "+
+		"If the value of this property is unspecified, then the new database will be created "+
+		"with the same dialect as the current database.",
+	databasepb.DatabaseDialect_DATABASE_DIALECT_UNSPECIFIED,
+	false,
+	nil,
+	connectionstate.ContextUser,
+	parseDatabaseDialect,
+)
 var propertyAutoConfigEmulator = createConnectionProperty(
 	"auto_config_emulator",
 	"Automatically configure the connection to try to connect to the Cloud Spanner emulator (true/false). "+

driver.go

@@ -683,7 +683,7 @@ func createConnector(d *Driver, connectorConfig ConnectorConfig) (*connector, er
 			internaloption.SkipDialSettingsValidation(),
 		}
 		opts = append(emulatorOpts, opts...)
-		if err := autoConfigEmulator(context.Background(), connectorConfig.Host, connectorConfig.Project, connectorConfig.Instance, connectorConfig.Database, opts); err != nil {
+		if err := autoConfigEmulator(context.Background(), connectorConfig.Host, connectorConfig.Project, connectorConfig.Instance, connectorConfig.Database, propertyDialect.GetValueOrDefault(state), opts); err != nil {
 			return nil, err
 		}
 	}
@@ -1548,6 +1548,19 @@ func parseRpcPriority(val string) (spannerpb.RequestOptions_Priority, error) {
 	return spannerpb.RequestOptions_PRIORITY_UNSPECIFIED, status.Errorf(codes.InvalidArgument, "invalid or unsupported priority: %v", val)
 }
 
+func parseDatabaseDialect(val string) (databasepb.DatabaseDialect, error) {
+	val = strings.ToUpper(val)
+	if dialect, ok := databasepb.DatabaseDialect_value[val]; ok {
+		return databasepb.DatabaseDialect(dialect), nil
+	}
+	if !strings.HasPrefix(val, "DATABASEDIALECT_") {
+		if dialect, ok := databasepb.DatabaseDialect_value["DATABASEDIALECT_"+val]; ok {
+			return databasepb.DatabaseDialect(dialect), nil
+		}
+	}
+	return databasepb.DatabaseDialect_DATABASE_DIALECT_UNSPECIFIED, status.Errorf(codes.InvalidArgument, "invalid or unsupported dialect: %v", val)
+}
+
 func parseIsolationLevel(val string) (sql.IsolationLevel, error) {
 	s := strings.ToLower(strings.TrimSpace(val))
 	s = strings.ReplaceAll(s, " ", "")

emulator_util.go

@@ -20,20 +20,20 @@ import (
 
 	"cloud.google.com/go/spanner"
 	database "cloud.google.com/go/spanner/admin/database/apiv1"
-	databasepb "cloud.google.com/go/spanner/admin/database/apiv1/databasepb"
+	"cloud.google.com/go/spanner/admin/database/apiv1/databasepb"
 	instance "cloud.google.com/go/spanner/admin/instance/apiv1"
-	instancepb "cloud.google.com/go/spanner/admin/instance/apiv1/instancepb"
+	"cloud.google.com/go/spanner/admin/instance/apiv1/instancepb"
 	"google.golang.org/api/option"
 	"google.golang.org/grpc/codes"
 )
 
-func autoConfigEmulator(ctx context.Context, host, project, instance, database string, opts []option.ClientOption) error {
+func autoConfigEmulator(ctx context.Context, host, project, instance, database string, dialect databasepb.DatabaseDialect, opts []option.ClientOption) error {
 	if err := createInstance(project, instance, opts); err != nil {
 		if spanner.ErrCode(err) != codes.AlreadyExists {
 			return err
 		}
 	}
-	if err := createDatabase(project, instance, database, opts); err != nil {
+	if err := createDatabase(project, instance, database, dialect, opts); err != nil {
 		if spanner.ErrCode(err) != codes.AlreadyExists {
 			return err
 		}
@@ -47,7 +47,7 @@ func createInstance(projectId, instanceId string, opts []option.ClientOption) er
 	if err != nil {
 		return err
 	}
-	defer instanceAdmin.Close()
+	defer func() { _ = instanceAdmin.Close() }()
 	op, err := instanceAdmin.CreateInstance(ctx, &instancepb.CreateInstanceRequest{
 		Parent:     fmt.Sprintf("projects/%s", projectId),
 		InstanceId: instanceId,
@@ -67,16 +67,21 @@ func createInstance(projectId, instanceId string, opts []option.ClientOption) er
 	return nil
 }
 
-func createDatabase(projectId, instanceId, databaseId string, opts []option.ClientOption) error {
+func createDatabase(projectId, instanceId, databaseId string, dialect databasepb.DatabaseDialect, opts []option.ClientOption) error {
 	ctx := context.Background()
 	databaseAdminClient, err := database.NewDatabaseAdminClient(ctx, opts...)
 	if err != nil {
 		return err
 	}
-	defer databaseAdminClient.Close()
+	defer func() { _ = databaseAdminClient.Close() }()
+	createStatement := fmt.Sprintf("CREATE DATABASE `%s`", databaseId)
+	if dialect == databasepb.DatabaseDialect_POSTGRESQL {
+		createStatement = fmt.Sprintf(`CREATE DATABASE "%s"`, databaseId)
+	}
 	opDB, err := databaseAdminClient.CreateDatabase(ctx, &databasepb.CreateDatabaseRequest{
 		Parent:          fmt.Sprintf("projects/%s/instances/%s", projectId, instanceId),
-		CreateStatement: fmt.Sprintf("CREATE DATABASE `%s`", databaseId),
+		CreateStatement: createStatement,
+		DatabaseDialect: dialect,
 	})
 	if err != nil {
 		return err

integration_test.go

@@ -298,6 +298,35 @@ func TestAutoConfigEmulator(t *testing.T) {
 	}
 }
 
+func TestAutoConfigEmulatorPostgreSql(t *testing.T) {
+	skipIfShort(t)
+	if !runsOnEmulator() {
+		t.Skip("autoConfigEmulator=true only works when connected to the emulator")
+	}
+	t.Parallel()
+
+	ctx := context.Background()
+	for range 2 {
+		db, err := sql.Open("spanner", "projects/emulator-project/instances/test-instance/databases/test-database;autoConfigEmulator=true;dialect=postgresql")
+		if err != nil {
+			t.Fatalf("could not connect to emulator: %v", err)
+		}
+		// Execute a query that only works on PostgreSQL.
+		row := db.QueryRowContext(ctx, "select $1", "Hello World")
+		if row.Err() != nil {
+			t.Fatalf("could not execute select: %v", row.Err())
+		}
+		var msg string
+		if err := row.Scan(&msg); err != nil {
+			t.Fatalf("could not scan value from select: %v", err)
+		}
+		if g, w := msg, "Hello World"; g != w {
+			t.Fatalf("value mismatch:\n Got %v\nWant %v", g, w)
+		}
+		_ = db.Close()
+	}
+}
+
 func TestQueryContext(t *testing.T) {
 	skipIfShort(t)
 	t.Parallel()