Merge branch 'timestamp-bound-exec-option' into ado-net-driver

Author: olavloite

conn.go

@@ -420,6 +420,16 @@ func (c *conn) setReadOnlyStaleness(staleness spanner.TimestampBound) (driver.Re
 	return driver.ResultNoRows, nil
 }
 
+func (c *conn) readOnlyStalenessPointer() *spanner.TimestampBound {
+	val := propertyReadOnlyStaleness.GetConnectionPropertyValue(c.state)
+	if val == nil || !val.HasValue() {
+		return nil
+	}
+	staleness, _ := val.GetValue()
+	timestampBound := staleness.(spanner.TimestampBound)
+	return &timestampBound
+}
+
 func (c *conn) IsolationLevel() sql.IsolationLevel {
 	return propertyIsolationLevel.GetValueOrDefault(c.state)
 }
@@ -1205,6 +1215,7 @@ func (c *conn) options(reset bool) (*ExecOptions, error) {
 			},
 		},
 		PartitionedQueryOptions: PartitionedQueryOptions{},
+		TimestampBound:          c.readOnlyStalenessPointer(),
 	}
 	if c.tempExecOptions != nil {
 		effectiveOptions.merge(c.tempExecOptions)
@@ -1585,6 +1596,9 @@ func (c *conn) Rollback(ctx context.Context) error {
 }
 
 func queryInSingleUse(ctx context.Context, c *spanner.Client, statement spanner.Statement, statementInfo *parser.StatementInfo, tb spanner.TimestampBound, options *ExecOptions) *spanner.RowIterator {
+	if options.TimestampBound != nil {
+		tb = *options.TimestampBound
+	}
 	return c.Single().WithTimestampBound(tb).QueryWithOptions(ctx, statement, options.QueryOptions)
 }
 

conn_with_mockserver_test.go

@@ -681,6 +681,34 @@ func TestSetLocalReadLockMode(t *testing.T) {
 	}
 }
 
+func TestTimestampBound(t *testing.T) {
+	t.Parallel()
+
+	db, server, teardown := setupTestDBConnection(t)
+	defer teardown()
+	ctx := context.Background()
+
+	staleness := spanner.MaxStaleness(10 * time.Second)
+	row := db.QueryRowContext(ctx, testutil.SelectFooFromBar, ExecOptions{TimestampBound: &staleness})
+	if row.Err() != nil {
+		t.Fatal(row.Err())
+	}
+	var val int64
+	if err := row.Scan(&val); err != nil {
+		t.Fatal(err)
+	}
+
+	requests := server.TestSpanner.DrainRequestsFromServer()
+	executeRequests := testutil.RequestsOfType(requests, reflect.TypeOf(&spannerpb.ExecuteSqlRequest{}))
+	if g, w := len(executeRequests), 1; g != w {
+		t.Fatalf("execute requests count mismatch\n Got: %v\nWant: %v", g, w)
+	}
+	request := executeRequests[0].(*spannerpb.ExecuteSqlRequest)
+	if g, w := request.Transaction.GetSingleUse().GetReadOnly().GetMaxStaleness().GetSeconds(), int64(10); g != w {
+		t.Fatalf("read staleness mismatch\n Got: %v\nWant: %v", g, w)
+	}
+}
+
 func TestCreateDatabase(t *testing.T) {
 	t.Parallel()
 

driver.go

@@ -173,6 +173,10 @@ type ExecOptions struct {
 	TransactionOptions spanner.TransactionOptions
 	// QueryOptions are the query options that will be used for the statement.
 	QueryOptions spanner.QueryOptions
+	// TimestampBound is the timestamp bound that will be used for the statement
+	// if it is a query outside a transaction. Setting this option will override
+	// the default TimestampBound that is set on the connection.
+	TimestampBound *spanner.TimestampBound
 
 	// PartitionedQueryOptions are used for partitioned queries, and ignored
 	// for all other statements.
@@ -246,6 +250,9 @@ func (dest *ExecOptions) merge(src *ExecOptions) {
 	if src.AutocommitDMLMode != Unspecified {
 		dest.AutocommitDMLMode = src.AutocommitDMLMode
 	}
+	if src.TimestampBound != nil {
+		dest.TimestampBound = src.TimestampBound
+	}
 	if src.PropertyValues != nil {
 		dest.PropertyValues = append(dest.PropertyValues, src.PropertyValues...)
 	}

drivers/spanner-ado-net/spanner-ado-net-tests/BasicTests.cs

@@ -16,6 +16,7 @@
 using System.Text.Json;
 using Google.Cloud.Spanner.V1;
 using Google.Cloud.SpannerLib.MockServer;
+using Google.Protobuf.WellKnownTypes;
 
 namespace Google.Cloud.Spanner.DataProvider.Tests;
 
@@ -66,6 +67,34 @@ public void TestExecuteParameterizedQuery()
             Assert.That(reader.GetInt64(0), Is.EqualTo(1));
         }
     }
+    
+    [Test]
+    public void TestExecuteStaleQuery()
+    {
+        using var connection = new SpannerConnection();
+        connection.ConnectionString = ConnectionString;
+        connection.Open();
+        
+        using var cmd = connection.CreateCommand();
+        cmd.CommandText = "SELECT 1";
+        cmd.SingleUseReadOnlyTransactionOptions = new TransactionOptions.Types.ReadOnly
+        {
+            ExactStaleness = Duration.FromTimeSpan(TimeSpan.FromSeconds(10)),
+        };
+        using var reader = cmd.ExecuteReader();
+        while (reader.Read())
+        {
+            Assert.That(reader.GetInt64(0), Is.EqualTo(1));
+        }
+
+        var request = Fixture.SpannerMock.Requests.OfType<ExecuteSqlRequest>().First();
+        Assert.That(request, Is.Not.Null);
+        Assert.That(request.Transaction, Is.Not.Null);
+        Assert.That(request.Transaction.SingleUse, Is.Not.Null);
+        Assert.That(request.Transaction.SingleUse.ReadOnly, Is.Not.Null);
+        Assert.That(request.Transaction.SingleUse.ReadOnly.ExactStaleness, Is.Not.Null);
+        Assert.That(request.Transaction.SingleUse.ReadOnly.ExactStaleness.Seconds, Is.EqualTo(10));
+    }
 
     [Test]
     public void TestInsertAllDataTypes()

spannerlib/api/connection.go

@@ -438,9 +438,8 @@ func extractParams(directExecuteContext context.Context, statement *spannerpb.Ex
 	}
 	params := make([]any, paramsLen)
 	params = append(params, spannerdriver.ExecOptions{
-		DecodeOption: spannerdriver.DecodeOptionProto,
-		// TODO: Implement support for passing in stale query options
-		// TimestampBound:          extractTimestampBound(statement),
+		DecodeOption:            spannerdriver.DecodeOptionProto,
+		TimestampBound:          extractTimestampBound(statement),
 		ReturnResultSetMetadata: true,
 		ReturnResultSetStats:    true,
 		DirectExecuteQuery:      true,
@@ -470,6 +469,26 @@ func extractParams(directExecuteContext context.Context, statement *spannerpb.Ex
 	return params
 }
 
+func extractTimestampBound(statement *spannerpb.ExecuteSqlRequest) *spanner.TimestampBound {
+	if statement.Transaction != nil && statement.Transaction.GetSingleUse() != nil && statement.Transaction.GetSingleUse().GetReadOnly() != nil {
+		ro := statement.Transaction.GetSingleUse().GetReadOnly()
+		var t spanner.TimestampBound
+		if ro.GetStrong() {
+			t = spanner.StrongRead()
+		} else if ro.GetMaxStaleness() != nil {
+			t = spanner.MaxStaleness(ro.GetMaxStaleness().AsDuration())
+		} else if ro.GetExactStaleness() != nil {
+			t = spanner.ExactStaleness(ro.GetExactStaleness().AsDuration())
+		} else if ro.GetMinReadTimestamp() != nil {
+			t = spanner.MinReadTimestamp(ro.GetMinReadTimestamp().AsTime())
+		} else if ro.GetReadTimestamp() != nil {
+			t = spanner.ReadTimestamp(ro.GetReadTimestamp().AsTime())
+		}
+		return &t
+	}
+	return nil
+}
+
 func determineBatchType(conn *Connection, statements []*spannerpb.ExecuteBatchDmlRequest_Statement) (parser.BatchType, error) {
 	if len(statements) == 0 {
 		return parser.BatchTypeDdl, status.Errorf(codes.InvalidArgument, "cannot determine type of an empty batch")