chore: move commit_response to a connection variable (#506)

Move commit_response and commit_timestamp to generic connection variables and
remove the regex-based SHOW statement for them.

Author: olavloite

client_side_statement.go

@@ -48,19 +48,6 @@ import (
 type statementExecutor struct {
 }
 
-func (s *statementExecutor) ShowCommitTimestamp(_ context.Context, c *conn, _ string, opts *ExecOptions, _ []driver.NamedValue) (driver.Rows, error) {
-	ts, err := c.CommitTimestamp()
-	var commitTs *time.Time
-	if err == nil {
-		commitTs = &ts
-	}
-	it, err := createTimestampIterator("CommitTimestamp", commitTs)
-	if err != nil {
-		return nil, err
-	}
-	return createRows(it, opts), nil
-}
-
 func (s *statementExecutor) ShowRetryAbortsInternally(_ context.Context, c *conn, _ string, opts *ExecOptions, _ []driver.NamedValue) (driver.Rows, error) {
 	it, err := createBooleanIterator("RetryAbortsInternally", c.RetryAbortsInternally())
 	if err != nil {

client_side_statement_test.go

@@ -295,8 +295,12 @@ func TestStatementExecutor_ReadOnlyStaleness(t *testing.T) {
 func TestShowCommitTimestamp(t *testing.T) {
 	t.Parallel()
 
-	c := &conn{logger: noopLogger, state: createInitialConnectionState(connectionstate.TypeNonTransactional, map[string]connectionstate.ConnectionPropertyValue{})}
-	s := &statementExecutor{}
+	parser, _ := newStatementParser(databasepb.DatabaseDialect_GOOGLE_STANDARD_SQL, 1000)
+	c := &conn{
+		logger: noopLogger,
+		parser: parser,
+		state:  createInitialConnectionState(connectionstate.TypeNonTransactional, map[string]connectionstate.ConnectionPropertyValue{}),
+	}
 	ctx := context.Background()
 
 	ts := time.Now()
@@ -307,17 +311,17 @@ func TestShowCommitTimestamp(t *testing.T) {
 		{nil},
 	} {
 		if test.wantValue == nil {
-			c.commitResponse = nil
+			c.clearCommitResponse()
 		} else {
-			c.commitResponse = &spanner.CommitResponse{CommitTs: *test.wantValue}
+			c.setCommitResponse(&spanner.CommitResponse{CommitTs: *test.wantValue})
 		}
 
-		it, err := s.ShowCommitTimestamp(ctx, c, "", &ExecOptions{}, nil)
+		it, err := c.QueryContext(ctx, "show variable commit_timestamp", []driver.NamedValue{})
 		if err != nil {
 			t.Fatalf("could not get current commit timestamp from connection: %v", err)
 		}
 		cols := it.Columns()
-		wantCols := []string{"CommitTimestamp"}
+		wantCols := []string{"commit_timestamp"}
 		if !cmp.Equal(cols, wantCols) {
 			t.Fatalf("column names mismatch\nGot: %v\nWant: %v", cols, wantCols)
 		}

client_side_statements_json.go

@@ -17,15 +17,6 @@ package spannerdriver
 var jsonFile = `{
   "statements":
   [
-	{
-	  "name": "SHOW VARIABLE COMMIT_TIMESTAMP",
-	  "executorName": "ClientSideStatementNoParamExecutor",
-	  "resultType": "RESULT_SET",
-	  "regex": "(?is)\\A\\s*show\\s+variable\\s+commit_timestamp\\s*\\z",
-	  "method": "statementShowCommitTimestamp",
-	  "exampleStatements": ["show variable commit_timestamp"],
-	  "examplePrerequisiteStatements": ["update foo set bar=1"]
-	},
 	{
       "name": "SHOW VARIABLE RETRY_ABORTS_INTERNALLY",
       "executorName": "ClientSideStatementNoParamExecutor",

conn.go

@@ -245,18 +245,17 @@ type SpannerConn interface {
 var _ SpannerConn = &conn{}
 
 type conn struct {
-	parser         *statementParser
-	connector      *connector
-	closed         bool
-	client         *spanner.Client
-	adminClient    *adminapi.DatabaseAdminClient
-	connId         string
-	logger         *slog.Logger
-	tx             contextTransaction
-	prevTx         contextTransaction
-	resetForRetry  bool
-	commitResponse *spanner.CommitResponse
-	database       string
+	parser        *statementParser
+	connector     *connector
+	closed        bool
+	client        *spanner.Client
+	adminClient   *adminapi.DatabaseAdminClient
+	connId        string
+	logger        *slog.Logger
+	tx            contextTransaction
+	prevTx        contextTransaction
+	resetForRetry bool
+	database      string
 
 	execSingleQuery              func(ctx context.Context, c *spanner.Client, statement spanner.Statement, bound spanner.TimestampBound, options *ExecOptions) *spanner.RowIterator
 	execSingleQueryTransactional func(ctx context.Context, c *spanner.Client, statement spanner.Statement, options *ExecOptions) (rowIterator, *spanner.CommitResponse, error)
@@ -286,17 +285,33 @@ func (c *conn) UnderlyingClient() (*spanner.Client, error) {
 }
 
 func (c *conn) CommitTimestamp() (time.Time, error) {
-	if c.commitResponse == nil {
+	ts := propertyCommitTimestamp.GetValueOrDefault(c.state)
+	if ts == nil {
 		return time.Time{}, spanner.ToSpannerError(status.Error(codes.FailedPrecondition, "this connection has not executed a read/write transaction that committed successfully"))
 	}
-	return c.commitResponse.CommitTs, nil
+	return *ts, nil
 }
 
 func (c *conn) CommitResponse() (commitResponse *spanner.CommitResponse, err error) {
-	if c.commitResponse == nil {
+	resp := propertyCommitResponse.GetValueOrDefault(c.state)
+	if resp == nil {
 		return nil, spanner.ToSpannerError(status.Error(codes.FailedPrecondition, "this connection has not executed a read/write transaction that committed successfully"))
 	}
-	return c.commitResponse, nil
+	return resp, nil
+}
+
+func (c *conn) clearCommitResponse() {
+	_ = propertyCommitResponse.SetValue(c.state, nil, connectionstate.ContextUser)
+	_ = propertyCommitTimestamp.SetValue(c.state, nil, connectionstate.ContextUser)
+}
+
+func (c *conn) setCommitResponse(commitResponse *spanner.CommitResponse) {
+	if commitResponse == nil {
+		c.clearCommitResponse()
+		return
+	}
+	_ = propertyCommitResponse.SetValue(c.state, commitResponse, connectionstate.ContextUser)
+	_ = propertyCommitTimestamp.SetValue(c.state, &commitResponse.CommitTs, connectionstate.ContextUser)
 }
 
 func (c *conn) showConnectionVariable(identifier identifier) (any, bool, error) {
@@ -715,7 +730,6 @@ func (c *conn) ResetSession(_ context.Context) error {
 			return driver.ErrBadConn
 		}
 	}
-	c.commitResponse = nil
 	c.batch = nil
 
 	_ = c.state.Reset(connectionstate.ContextUser)
@@ -805,7 +819,7 @@ func (c *conn) QueryContext(ctx context.Context, query string, args []driver.Nam
 
 func (c *conn) queryContext(ctx context.Context, query string, execOptions *ExecOptions, args []driver.NamedValue) (driver.Rows, error) {
 	// Clear the commit timestamp of this connection before we execute the query.
-	c.commitResponse = nil
+	c.clearCommitResponse()
 	// Check if the execution options contains an instruction to execute
 	// a specific partition of a PartitionedQuery.
 	if pq := execOptions.PartitionedQueryOptions.ExecutePartition.PartitionedQuery; pq != nil {
@@ -830,7 +844,7 @@ func (c *conn) queryContext(ctx context.Context, query string, execOptions *Exec
 			if err != nil {
 				return nil, err
 			}
-			c.commitResponse = commitResponse
+			c.setCommitResponse(commitResponse)
 		} else if execOptions.PartitionedQueryOptions.PartitionQuery {
 			return nil, spanner.ToSpannerError(status.Errorf(codes.FailedPrecondition, "PartitionQuery is only supported in batch read-only transactions"))
 		} else if execOptions.PartitionedQueryOptions.AutoPartitionQuery {
@@ -877,7 +891,7 @@ func (c *conn) ExecContext(ctx context.Context, query string, args []driver.Name
 
 func (c *conn) execContext(ctx context.Context, query string, execOptions *ExecOptions, args []driver.NamedValue) (driver.Result, error) {
 	// Clear the commit timestamp of this connection before we execute the statement.
-	c.commitResponse = nil
+	c.clearCommitResponse()
 
 	statementInfo := c.parser.detectStatementType(query)
 	// Use admin API if DDL statement is provided.
@@ -917,7 +931,7 @@ func (c *conn) execContext(ctx context.Context, query string, execOptions *ExecO
 			if dmlMode == Transactional {
 				res, commitResponse, err = c.execSingleDMLTransactional(ctx, c.client, ss, statementInfo, execOptions)
 				if err == nil {
-					c.commitResponse = commitResponse
+					c.setCommitResponse(commitResponse)
 				}
 			} else if dmlMode == PartitionedNonAtomic {
 				var rowsAffected int64
@@ -1174,7 +1188,7 @@ func (c *conn) BeginTx(ctx context.Context, driverOpts driver.TxOptions) (driver
 			c.prevTx = c.tx
 			c.tx = nil
 			if commitErr == nil {
-				c.commitResponse = commitResponse
+				c.setCommitResponse(commitResponse)
 				if result == txResultCommit {
 					_ = c.state.Commit()
 				} else {
@@ -1187,7 +1201,7 @@ func (c *conn) BeginTx(ctx context.Context, driverOpts driver.TxOptions) (driver
 		// Disable internal retries if any of these options have been set.
 		retryAborts: !disableInternalRetries && !disableRetryAborts,
 	}
-	c.commitResponse = nil
+	c.clearCommitResponse()
 	return c.tx, nil
 }
 

connection_properties.go

@@ -406,6 +406,33 @@ var propertyDisableStatementCache = createConnectionProperty(
 	connectionstate.ConvertBool,
 )
 
+// Generated read-only properties. These cannot be set by the user anywhere.
+var propertyCommitTimestamp = createReadOnlyConnectionProperty(
+	"commit_timestamp",
+	"The commit timestamp of the last implicit or explicit read/write transaction that "+
+		"was executed on the connection, or an error if the connection has not executed a read/write transaction "+
+		"that committed successfully. The timestamp is in the local timezone.",
+	(*time.Time)(nil),
+	false,
+	nil,
+	connectionstate.ContextUser,
+)
+var propertyCommitResponse = createReadOnlyConnectionProperty(
+	"commit_response",
+	"The commit response of the last implicit or explicit read/write transaction that "+
+		"was executed on the connection, or an error if the connection has not executed a read/write transaction "+
+		"that committed successfully.",
+	(*spanner.CommitResponse)(nil),
+	false,
+	nil,
+	connectionstate.ContextUser,
+)
+
+func createReadOnlyConnectionProperty[T comparable](name, description string, defaultValue T, hasDefaultValue bool, validValues []T, context connectionstate.Context) *connectionstate.TypedConnectionProperty[T] {
+	converter := connectionstate.CreateReadOnlyConverter[T](name)
+	return createConnectionProperty(name, description, defaultValue, hasDefaultValue, validValues, context, converter)
+}
+
 func createConnectionProperty[T comparable](name, description string, defaultValue T, hasDefaultValue bool, validValues []T, context connectionstate.Context, converter func(value string) (T, error)) *connectionstate.TypedConnectionProperty[T] {
 	prop := connectionstate.CreateConnectionProperty(name, description, defaultValue, hasDefaultValue, validValues, context, converter)
 	connectionProperties[prop.Key()] = prop

connectionstate/converters.go

@@ -25,6 +25,13 @@ import (
 	"google.golang.org/grpc/status"
 )
 
+func CreateReadOnlyConverter[T any](property string) func(value string) (T, error) {
+	return func(value string) (T, error) {
+		var t T
+		return t, status.Errorf(codes.FailedPrecondition, "property %s is read-only", property)
+	}
+}
+
 func ConvertBool(value string) (bool, error) {
 	return strconv.ParseBool(value)
 }

driver_test.go

@@ -487,9 +487,10 @@ func TestConnection_Reset(t *testing.T) {
 		connector: &connector{
 			connectorConfig: ConnectorConfig{},
 		},
-		state:          createInitialConnectionState(connectionstate.TypeTransactional, map[string]connectionstate.ConnectionPropertyValue{}),
-		batch:          &batch{tp: dml},
-		commitResponse: &spanner.CommitResponse{},
+		state: createInitialConnectionState(connectionstate.TypeTransactional, map[string]connectionstate.ConnectionPropertyValue{
+			propertyCommitResponse.Key(): propertyCommitResponse.CreateTypedInitialValue(nil),
+		}),
+		batch: &batch{tp: dml},
 		tx: &readOnlyTransaction{
 			logger: noopLogger,
 			close: func(_ txResult) {
@@ -498,6 +499,7 @@ func TestConnection_Reset(t *testing.T) {
 		},
 	}
 
+	c.setCommitResponse(&spanner.CommitResponse{})
 	if err := c.SetReadOnlyStaleness(spanner.ExactStaleness(time.Second)); err != nil {
 		t.Fatal(err)
 	}
@@ -510,7 +512,7 @@ func TestConnection_Reset(t *testing.T) {
 	if c.inBatch() {
 		t.Error("failed to clear batch")
 	}
-	if c.commitResponse != nil {
+	if _, err := c.CommitResponse(); err == nil {
 		t.Errorf("failed to clear commit response")
 	}
 	if !txClosed {

driver_with_mockserver_test.go

@@ -3363,6 +3363,77 @@ func TestShowVariableCommitTimestamp(t *testing.T) {
 			t.Fatalf("got zero commit timestamp: %v", ts)
 		}
 	}
+
+	// Verify that we cannot manually set the commit_timestamp variable.
+	_, err = conn.ExecContext(ctx, "set commit_timestamp='2025-09-02T10:00:00Z'")
+	if g, w := spanner.ErrCode(err), codes.FailedPrecondition; g != w {
+		t.Fatalf("set commit timestamp error code mismatch\n Got: %v\nWant: %v", g, w)
+	}
+	if g, w := err.Error(), "rpc error: code = FailedPrecondition desc = property commit_timestamp is read-only"; g != w {
+		t.Fatalf("set commit timestamp error message mismatch\n Got: %v\nWant: %v", g, w)
+	}
+}
+
+func TestShowVariableCommitResponse(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	db, _, teardown := setupTestDBConnection(t)
+	defer teardown()
+
+	conn, err := db.Conn(ctx)
+	defer func() {
+		if err := conn.Close(); err != nil {
+			t.Fatal(err)
+		}
+	}()
+	if err != nil {
+		t.Fatalf("failed to get a connection: %v", err)
+	}
+	tx, err := conn.BeginTx(ctx, nil)
+	if err != nil {
+		t.Fatalf("failed to start transaction: %v", err)
+	}
+	if err := tx.Commit(); err != nil {
+		t.Fatalf("commit failed: %v", err)
+	}
+	// Get the commit response from the connection using a custom SQL statement.
+	// We do this in a simple loop to verify that we can get it multiple times.
+	for i := 0; i < 2; i++ {
+		var resp string
+		if err := conn.QueryRowContext(ctx, "SHOW VARIABLE commit_response").Scan(&resp); err != nil {
+			t.Fatalf("failed to get commit response: %v", err)
+		}
+		if resp == "" {
+			t.Fatalf("got empty commit response: %v", resp)
+		}
+	}
+
+	// Verify that we cannot manually set the commit_response variable.
+	_, err = conn.ExecContext(ctx, "set commit_response='2025-09-02T10:00:00Z'")
+	if g, w := spanner.ErrCode(err), codes.FailedPrecondition; g != w {
+		t.Fatalf("set commit response error code mismatch\n Got: %v\nWant: %v", g, w)
+	}
+	if g, w := err.Error(), "rpc error: code = FailedPrecondition desc = property commit_response is read-only"; g != w {
+		t.Fatalf("set commit response error message mismatch\n Got: %v\nWant: %v", g, w)
+	}
+}
+
+func TestSetCommitTimestampInConnectionString(t *testing.T) {
+	t.Parallel()
+
+	_, server, teardown := setupTestDBConnection(t)
+	defer teardown()
+
+	_, err := sql.Open(
+		"spanner",
+		fmt.Sprintf("%s/projects/p/instances/i/databases/d?useplaintext=true;commit_timestamp='2025-09-02T10:00:00Z'", server.Address))
+	if g, w := spanner.ErrCode(err), codes.FailedPrecondition; g != w {
+		t.Fatalf("error code mismatch\n Got: %v\nWant: %v", g, w)
+	}
+	if g, w := err.Error(), "rpc error: code = FailedPrecondition desc = property commit_timestamp is read-only"; g != w {
+		t.Fatalf("error message mismatch\n Got: %v\nWant: %v", g, w)
+	}
 }
 
 func TestMinSessions(t *testing.T) {

statements.go

@@ -3,6 +3,7 @@ package spannerdriver
 import (
 	"context"
 	"database/sql/driver"
+	"encoding/json"
 	"fmt"
 	"time"
 
@@ -112,15 +113,19 @@ func (s *parsedShowStatement) queryContext(ctx context.Context, c *conn, params
 	case *time.Time:
 		it, err = createTimestampIterator(col, val)
 	default:
-		if stringerVal, ok := val.(fmt.Stringer); ok {
-			if hasValue {
-				it, err = createStringIterator(col, stringerVal.String())
+		stringVal := ""
+		if hasValue {
+			if stringerVal, ok := val.(fmt.Stringer); ok {
+				stringVal = stringerVal.String()
 			} else {
-				it, err = createStringIterator(col, "")
+				jsonVal, err := json.Marshal(val)
+				if err != nil {
+					return nil, status.Errorf(codes.InvalidArgument, "unsupported type: %T", val)
+				}
+				stringVal = string(jsonVal)
 			}
-		} else {
-			err = status.Errorf(codes.InvalidArgument, "unsupported type: %T", val)
 		}
+		it, err = createStringIterator(col, stringVal)
 	}
 	if err != nil {
 		return nil, err