Merge branch 'main' into spanner-lib

Author: olavloite

.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "1.15.0"
+  ".": "1.16.0"
 }

CHANGES.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [1.16.0](https://github.com/googleapis/go-sql-spanner/compare/v1.15.0...v1.16.0) (2025-07-03)
+
+
+### Features
+
+* Add BeginTransactionOption to configure how to begin a transaction ([21ed1e3](https://github.com/googleapis/go-sql-spanner/commit/21ed1e3a744d7052781e6f28aa7f25dc4ed891df))
+* Add RunDmlBatch function with typed return value ([#471](https://github.com/googleapis/go-sql-spanner/issues/471)) ([12ead7c](https://github.com/googleapis/go-sql-spanner/commit/12ead7c5df87813b167ab9dec025cf78fee520a2))
+* Return metadata and stats for client-side statements ([#470](https://github.com/googleapis/go-sql-spanner/issues/470)) ([19238ce](https://github.com/googleapis/go-sql-spanner/commit/19238cec2f77998c0e8052794be2c25167057b04))
+
+
+### Bug Fixes
+
+* Update all dependencies ([#464](https://github.com/googleapis/go-sql-spanner/issues/464)) ([574d6fe](https://github.com/googleapis/go-sql-spanner/commit/574d6fe6fa42a138b0123ac0bcf756413c87ea25))
+* Use client opts to auto configure emulator instead of environment variable ([#468](https://github.com/googleapis/go-sql-spanner/issues/468)) ([a518727](https://github.com/googleapis/go-sql-spanner/commit/a5187277ae02be0e3935d746751aadd76beb0c8e))
+
+
+### Performance Improvements
+
+* Inline BeginTransaction with first statement ([21ed1e3](https://github.com/googleapis/go-sql-spanner/commit/21ed1e3a744d7052781e6f28aa7f25dc4ed891df))
+
 ## [1.15.0](https://github.com/googleapis/go-sql-spanner/compare/v1.14.0...v1.15.0) (2025-06-27)
 
 

client_side_statement_test.go

@@ -22,8 +22,11 @@ import (
 	"time"
 
 	"cloud.google.com/go/spanner"
+	"cloud.google.com/go/spanner/apiv1/spannerpb"
 	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
 	"google.golang.org/grpc/codes"
+	"google.golang.org/protobuf/types/known/structpb"
 )
 
 func TestStatementExecutor_StartBatchDdl(t *testing.T) {
@@ -507,3 +510,100 @@ func TestStatementExecutor_SetTransactionTag(t *testing.T) {
 
 	}
 }
+
+func TestStatementExecutor_UsesExecOptions(t *testing.T) {
+	ctx := context.Background()
+	c := &conn{retryAborts: true, logger: noopLogger}
+	s := &statementExecutor{}
+
+	it, err := s.ShowTransactionTag(ctx, c, "", ExecOptions{DecodeOption: DecodeOptionProto, ReturnResultSetMetadata: true, ReturnResultSetStats: true}, nil)
+	if err != nil {
+		t.Fatalf("could not get current transaction tag value from connection: %v", err)
+	}
+	rows, ok := it.(driver.RowsNextResultSet)
+	if !ok {
+		t.Fatal("did not get RowsNextResultSet")
+	}
+	// The first result set contains the metadata.
+	cols := rows.Columns()
+	wantCols := []string{"metadata"}
+	if !cmp.Equal(cols, wantCols) {
+		t.Fatalf("column names mismatch\nGot: %v\nWant: %v", cols, wantCols)
+	}
+	wantValues := []driver.Value{&spannerpb.ResultSetMetadata{
+		RowType: &spannerpb.StructType{
+			Fields: []*spannerpb.StructType_Field{
+				{Name: "TransactionTag", Type: &spannerpb.Type{Code: spannerpb.TypeCode_STRING}},
+			},
+		},
+	}}
+	values := make([]driver.Value, len(cols))
+	if err := rows.Next(values); err != nil {
+		t.Fatalf("failed to get first row: %v", err)
+	}
+	if !cmp.Equal(values, wantValues, cmpopts.IgnoreUnexported(spannerpb.ResultSetMetadata{}, spannerpb.StructType{}, spannerpb.StructType_Field{}, spannerpb.Type{})) {
+		t.Fatalf("default transaction tag mismatch\nGot: %v\nWant: %v", values, wantValues)
+	}
+	if err := rows.Next(values); err != io.EOF {
+		t.Fatalf("error mismatch\nGot: %v\nWant: %v", err, io.EOF)
+	}
+
+	// Move to the next result set, which should contain the data.
+	if !rows.HasNextResultSet() {
+		t.Fatal("missing next result set")
+	}
+	if err := rows.NextResultSet(); err != nil {
+		t.Fatalf("error mismatch\n Got: %v\nWant: %v", err, nil)
+	}
+
+	cols = rows.Columns()
+	wantCols = []string{"TransactionTag"}
+	if !cmp.Equal(cols, wantCols) {
+		t.Fatalf("column names mismatch\nGot: %v\nWant: %v", cols, wantCols)
+	}
+	values = make([]driver.Value, len(cols))
+	if err := rows.Next(values); err != nil {
+		t.Fatalf("failed to get first row: %v", err)
+	}
+	// The value that we get should be the raw protobuf value.
+	wantValues = []driver.Value{spanner.GenericColumnValue{
+		Type:  &spannerpb.Type{Code: spannerpb.TypeCode_STRING},
+		Value: &structpb.Value{Kind: &structpb.Value_StringValue{StringValue: ""}},
+	}}
+	if !cmp.Equal(values, wantValues, cmpopts.IgnoreUnexported(spannerpb.Type{}, structpb.Value{})) {
+		t.Fatalf("default transaction tag mismatch\nGot: %v\nWant: %v", values, wantValues)
+	}
+	if err := rows.Next(values); err != io.EOF {
+		t.Fatalf("error mismatch\nGot: %v\nWant: %v", err, io.EOF)
+	}
+
+	// Move to the next result set, which should contain the ResultSetStats.
+	if !rows.HasNextResultSet() {
+		t.Fatal("missing next result set")
+	}
+	if err := rows.NextResultSet(); err != nil {
+		t.Fatalf("error mismatch\n Got: %v\nWant: %v", err, nil)
+	}
+	cols = rows.Columns()
+	wantCols = []string{"stats"}
+	if !cmp.Equal(cols, wantCols) {
+		t.Fatalf("column names mismatch\nGot: %v\nWant: %v", cols, wantCols)
+	}
+	wantValues = []driver.Value{&spannerpb.ResultSetStats{}}
+	values = make([]driver.Value, len(cols))
+	if err := rows.Next(values); err != nil {
+		t.Fatalf("failed to get first row: %v", err)
+	}
+	if !cmp.Equal(values, wantValues, cmpopts.IgnoreUnexported(spannerpb.ResultSetStats{})) {
+		t.Fatalf("ResultSetStats mismatch\nGot: %v\nWant: %v", values, wantValues)
+	}
+	if err := rows.Next(values); err != io.EOF {
+		t.Fatalf("error mismatch\nGot: %v\nWant: %v", err, io.EOF)
+	}
+
+	// There should be no more result sets.
+	if rows.HasNextResultSet() {
+		t.Fatal("got unexpected next result set")
+	}
+
+}

conn.go

@@ -513,7 +513,7 @@ func (c *conn) startBatchDDL() (driver.Result, error) {
 }
 
 func (c *conn) startBatchDML(automatic bool) (driver.Result, error) {
-	execOptions := c.options( /* reset = */ true)
+	execOptions := c.options( /*reset = */ true)
 
 	if c.inTransaction() {
 		return c.tx.StartBatchDML(execOptions.QueryOptions, automatic)

conn_with_mockserver_test.go

@@ -389,3 +389,82 @@ func TestDDLUsingQueryContextInReadWriteTransaction(t *testing.T) {
 		t.Fatalf("error mismatch\n Got: %v\nWant: %v", g, w)
 	}
 }
+
+func TestRunDmlBatch(t *testing.T) {
+	t.Parallel()
+
+	db, _, teardown := setupTestDBConnection(t)
+	defer teardown()
+	ctx := context.Background()
+
+	conn, err := db.Conn(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer silentClose(conn)
+	if err := conn.Raw(func(driverConn interface{}) error {
+		spannerConn, _ := driverConn.(SpannerConn)
+		return spannerConn.StartBatchDML()
+	}); err != nil {
+		t.Fatal(err)
+	}
+	// Buffer two DML statements.
+	for range 2 {
+		if _, err := conn.ExecContext(ctx, testutil.UpdateBarSetFoo); err != nil {
+			t.Fatal(err)
+		}
+	}
+	var res SpannerResult
+	if err := conn.Raw(func(driverConn interface{}) (err error) {
+		spannerConn, _ := driverConn.(SpannerConn)
+		res, err = spannerConn.RunDmlBatch(ctx)
+		return err
+	}); err != nil {
+		t.Fatal(err)
+	}
+	affected, err := res.BatchRowsAffected()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if g, w := affected, []int64{testutil.UpdateBarSetFooRowCount, testutil.UpdateBarSetFooRowCount}; !reflect.DeepEqual(g, w) {
+		t.Fatalf("affected mismatch\n Got: %v\nWant: %v", g, w)
+	}
+}
+
+func TestSetRetryAbortsInternallyInInactiveTransaction(t *testing.T) {
+	t.Parallel()
+
+	db, _, teardown := setupTestDBConnection(t)
+	defer teardown()
+	ctx := context.Background()
+
+	tx, err := db.BeginTx(ctx, &sql.TxOptions{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := tx.ExecContext(ctx, "set retry_aborts_internally = false"); err != nil {
+		t.Fatal(err)
+	}
+	_ = tx.Rollback()
+}
+
+func TestSetRetryAbortsInternallyInActiveTransaction(t *testing.T) {
+	t.Parallel()
+
+	db, _, teardown := setupTestDBConnection(t)
+	defer teardown()
+	ctx := context.Background()
+
+	tx, err := db.BeginTx(ctx, &sql.TxOptions{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := tx.ExecContext(ctx, testutil.UpdateBarSetFoo); err != nil {
+		t.Fatal(err)
+	}
+	_, err = tx.ExecContext(ctx, "set retry_aborts_internally = false")
+	if g, w := err.Error(), "spanner: code = \"FailedPrecondition\", desc = \"cannot change retry mode while a transaction is active\""; g != w {
+		t.Fatalf("error mismatch\n Got: %v\nWant: %v", g, w)
+	}
+	_ = tx.Rollback()
+}

driver.go

@@ -46,7 +46,7 @@ import (
 	"google.golang.org/grpc/status"
 )
 
-const userAgent = "go-sql-spanner/1.15.0" // x-release-please-version
+const userAgent = "go-sql-spanner/1.16.0" // x-release-please-version
 
 const gormModule = "github.com/googleapis/go-gorm-spanner"
 const gormUserAgent = "go-gorm-spanner"

driver_with_mockserver_test.go

@@ -2673,20 +2673,25 @@ func TestShowAndSetVariableRetryAbortsInternally(t *testing.T) {
 		}
 	}
 
-	tx, _ := c.BeginTx(ctx, nil)
-	defer func() { _ = tx.Rollback() }()
-	// Verify that the value can be set before the transaction has been activated.
-	if _, err = c.ExecContext(ctx, "SET RETRY_ABORTS_INTERNALLY = TRUE"); err != nil {
-		t.Fatalf("failed to set value for retry_aborts_internally for an inactive transaction: %v", err)
-	}
 	// Verify that the value cannot be set during an active transaction.
-	if _, err := tx.ExecContext(ctx, testutil.UpdateBarSetFoo); err != nil {
-		t.Fatalf("failed to execute test update statement: %v", err)
+	tx, _ := c.BeginTx(ctx, nil)
+	// Execute a statement to activate the transaction.
+	if _, err := c.ExecContext(ctx, testutil.UpdateBarSetFoo); err != nil {
+		t.Fatal(err)
 	}
 	_, err = c.ExecContext(ctx, "SET RETRY_ABORTS_INTERNALLY = TRUE")
 	if g, w := spanner.ErrCode(err), codes.FailedPrecondition; g != w {
 		t.Fatalf("error code mismatch for setting retry_aborts_internally during a transaction\nGot: %v\nWant: %v", g, w)
 	}
+	_ = tx.Rollback()
+
+	// Verify that the value can be set at the start of a transaction
+	// before any statements have been executed.
+	tx, _ = c.BeginTx(ctx, nil)
+	if _, err = c.ExecContext(ctx, "SET RETRY_ABORTS_INTERNALLY = TRUE"); err != nil {
+		t.Fatal(err)
+	}
+	_ = tx.Rollback()
 }
 
 func TestPartitionedDml(t *testing.T) {

examples/dml-batches/main.go

@@ -106,11 +106,17 @@ func dmlBatch(projectId, instanceId, databaseId string) error {
 		return fmt.Errorf("failed to insert: %v", err)
 	}
 	// Run the batch. This will apply all the batched DML statements to the database in one atomic operation.
-	if err := conn.Raw(func(driverConn interface{}) error {
-		return driverConn.(spannerdriver.SpannerConn).RunBatch(ctx)
+	var res spannerdriver.SpannerResult
+	if err := conn.Raw(func(driverConn interface{}) (err error) {
+		res, err = driverConn.(spannerdriver.SpannerConn).RunDmlBatch(ctx)
+		return err
 	}); err != nil {
 		return fmt.Errorf("failed to run DML batch: %v", err)
 	}
+	// BatchRowsAffected returns a slice with the affected rows per DML statement in the batch.
+	affected, _ := res.BatchRowsAffected()
+	fmt.Printf("Affected rows: %v\n", affected)
+
 	if err := db.QueryRowContext(ctx, "SELECT COUNT(*) FROM Singers").Scan(&c); err != nil {
 		return fmt.Errorf("failed to get singers count: %v", err)
 	}