test: add query all data types test

Author: olavloite

drivers/spanner-ado-net/spanner-ado-net-samples/Snippets/TransactionSample.cs

@@ -0,0 +1,53 @@
+// Copyright 2025 Google LLC
+//
+// 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
+//
+//     https://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.
+
+using System.Data;
+
+namespace Google.Cloud.Spanner.DataProvider.Samples.Snippets;
+
+/// <summary>
+/// This sample shows how to execute a read/write transaction using the Spanner ADO.NET data provider.
+/// </summary>
+public class TransactionSample
+{
+    public static async Task Run(string connectionString)
+    {
+        await using var connection = new SpannerConnection(connectionString);
+        await connection.OpenAsync();
+
+        // Start a read/write transaction by calling th standard BeginTransaction method.
+        await using var transaction = await connection.BeginTransactionAsync(IsolationLevel.RepeatableRead);
+        
+        // Execute a query that uses this transaction.
+        await using var command = connection.CreateCommand();
+        command.Transaction = transaction;
+        command.CommandText = "SELECT SingerId " +
+                              "FROM Singers " +
+                              "WHERE BirthDate IS NULL";
+        var updateCount = 0;
+        await using var reader = await command.ExecuteReaderAsync();
+        while (await reader.ReadAsync())
+        {
+            // Update the birthdate of each Singer without a known birthdate to a default value.
+            await using var updateCommand = connection.CreateCommand();
+            updateCommand.Transaction = transaction;
+            updateCommand.CommandText = "UPDATE Singers SET BirthDate=DATE '1900-01-01' WHERE SingerId=@singerId";
+            updateCommand.Parameters.AddWithValue("singerId", reader["SingerId"]);
+            await updateCommand.ExecuteNonQueryAsync();
+            updateCount++;
+        }
+        await transaction.CommitAsync();
+        Console.WriteLine($"Set a default birthdate for {updateCount} singers");
+    }
+}

drivers/spanner-ado-net/spanner-ado-net-samples/insert_sample_data.sql

@@ -16,4 +16,5 @@
 INSERT OR UPDATE INTO Singers (SingerId, FirstName, LastName, BirthDate, Picture) VALUES 
   (1, 'Mark', 'Richards', DATE '1990-11-09', NULL),
   (2, 'Catalina', 'Smith', DATE '1998-04-29', NULL),
-  (3, 'Alice', 'Trentor', DATE '1979-10-15', NULL);
+  (3, 'Alice', 'Trentor', DATE '1979-10-15', NULL),
+  (4, 'Lea', 'Martin', NULL, NULL);

drivers/spanner-ado-net/spanner-ado-net-specification-tests/DataReaderTests.cs

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+using System.Data;
 using AdoNet.Specification.Tests;
 using Google.Cloud.SpannerLib.MockServer;
 using Xunit;

drivers/spanner-ado-net/spanner-ado-net-specification-tests/GetValueConversionTests.cs

@@ -115,6 +115,10 @@ public class GetValueConversionTests(DbFactoryFixture fixture) : GetValueConvers
 
     public override void GetString_throws_for_zero_Single() => TestGetValue(DbType.Single, ValueKind.Zero, x => x.GetString(0), "0");
 
+    public override void GetString_throws_for_null_String_with_GetFieldValue() => TestGetValue(DbType.String, ValueKind.Null, x => x.GetFieldValue<string>(0), null);
+    
+    public override async Task GetString_throws_for_null_String_with_GetFieldValueAsync() => await TestGetValueAsync(DbType.String, ValueKind.Null, async x => await x.GetFieldValueAsync<string>(0), null);
+
     public override void GetDouble_throws_for_one_String_with_GetFieldValue() => TestGetValue(DbType.String, ValueKind.One, x => x.GetFieldValue<double>(0), 1.0d);
 
     public override async Task GetDouble_throws_for_one_String_with_GetFieldValueAsync() => await TestGetValueAsync(DbType.String, ValueKind.One, async x => await x.GetFieldValueAsync<double>(0), 1.0d);

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

@@ -142,6 +142,61 @@ public void TestInsertAllDataTypes()
 
         Assert.That(request.ParamTypes.Count, Is.EqualTo(0));
     }
+
+    [Test]
+    public void TestQueryAllDataTypes()
+    {
+        const string sql = "select * from all_types";
+        var result = RandomResultSetGenerator.Generate(10, allowNull: true);
+        Fixture.SpannerMock.AddOrUpdateStatementResult(sql, StatementResult.CreateQuery(result));
+        
+        using var connection = new SpannerConnection();
+        connection.ConnectionString = ConnectionString;
+        connection.Open();
+        
+        using var cmd = connection.CreateCommand();
+        cmd.CommandText = sql;
+        using var reader = cmd.ExecuteReader();
+        while (reader.Read())
+        {
+            var index = 0;
+            foreach (var field in result.Metadata.RowType.Fields)
+            {
+                Assert.That(reader[index], Is.EqualTo(reader[field.Name]));
+                index++;
+            }
+            Assert.That(reader.GetFieldValue<bool?>(reader.GetOrdinal("col_bool")), Is.EqualTo(ValueOrNull(reader["col_bool"])));
+            Assert.That(reader.GetFieldValue<byte[]>(reader.GetOrdinal("col_bytes")), Is.EqualTo(ValueOrNull(reader["col_bytes"])));
+            Assert.That(reader.GetFieldValue<DateOnly?>(reader.GetOrdinal("col_date")), Is.EqualTo(ValueOrNull(reader["col_date"])));
+            Assert.That(reader.GetFieldValue<float?>(reader.GetOrdinal("col_float32")), Is.EqualTo(ValueOrNull(reader["col_float32"])));
+            Assert.That(reader.GetFieldValue<double?>(reader.GetOrdinal("col_float64")), Is.EqualTo(ValueOrNull(reader["col_float64"])));
+            Assert.That(reader.GetFieldValue<long?>(reader.GetOrdinal("col_int64")), Is.EqualTo(ValueOrNull(reader["col_int64"])));
+            Assert.That(reader.GetFieldValue<TimeSpan?>(reader.GetOrdinal("col_interval")), Is.EqualTo(ValueOrNull(reader["col_interval"])));
+            Assert.That(reader.GetFieldValue<string?>(reader.GetOrdinal("col_json")), Is.EqualTo(ValueOrNull(reader["col_json"])));
+            Assert.That(reader.GetFieldValue<decimal?>(reader.GetOrdinal("col_numeric")), Is.EqualTo(ValueOrNull(reader["col_numeric"])));
+            Assert.That(reader.GetFieldValue<string?>(reader.GetOrdinal("col_string")), Is.EqualTo(ValueOrNull(reader["col_string"])));
+            Assert.That(reader.GetFieldValue<DateTime?>(reader.GetOrdinal("col_timestamp")), Is.EqualTo(ValueOrNull(reader["col_timestamp"])));
+            Assert.That(reader.GetFieldValue<Guid?>(reader.GetOrdinal("col_uuid")), Is.EqualTo(ValueOrNull(reader["col_uuid"])));
+            
+            Assert.That(reader.GetFieldValue<List<bool?>>(reader.GetOrdinal("col_array_bool")), Is.EqualTo(ValueOrNull(reader["col_array_bool"])));
+            Assert.That(reader.GetFieldValue<List<byte[]>>(reader.GetOrdinal("col_array_bytes")), Is.EqualTo(ValueOrNull(reader["col_array_bytes"])));
+            Assert.That(reader.GetFieldValue<List<DateOnly?>>(reader.GetOrdinal("col_array_date")), Is.EqualTo(ValueOrNull(reader["col_array_date"])));
+            Assert.That(reader.GetFieldValue<List<float?>>(reader.GetOrdinal("col_array_float32")), Is.EqualTo(ValueOrNull(reader["col_array_float32"])));
+            Assert.That(reader.GetFieldValue<List<double?>>(reader.GetOrdinal("col_array_float64")), Is.EqualTo(ValueOrNull(reader["col_array_float64"])));
+            Assert.That(reader.GetFieldValue<List<long?>>(reader.GetOrdinal("col_array_int64")), Is.EqualTo(ValueOrNull(reader["col_array_int64"])));
+            Assert.That(reader.GetFieldValue<List<TimeSpan?>>(reader.GetOrdinal("col_array_interval")), Is.EqualTo(ValueOrNull(reader["col_array_interval"])));
+            Assert.That(reader.GetFieldValue<List<string?>>(reader.GetOrdinal("col_array_json")), Is.EqualTo(ValueOrNull(reader["col_array_json"])));
+            Assert.That(reader.GetFieldValue<List<decimal?>>(reader.GetOrdinal("col_array_numeric")), Is.EqualTo(ValueOrNull(reader["col_array_numeric"])));
+            Assert.That(reader.GetFieldValue<List<string?>>(reader.GetOrdinal("col_array_string")), Is.EqualTo(ValueOrNull(reader["col_array_string"])));
+            Assert.That(reader.GetFieldValue<List<DateTime?>>(reader.GetOrdinal("col_array_timestamp")), Is.EqualTo(ValueOrNull(reader["col_array_timestamp"])));
+            Assert.That(reader.GetFieldValue<List<Guid?>>(reader.GetOrdinal("col_array_uuid")), Is.EqualTo(ValueOrNull(reader["col_array_uuid"])));
+        }
+    }
+
+    private static object? ValueOrNull(object value)
+    {
+        return value is DBNull ? null : value;
+    }
 
     [Test]
     public void TestExecuteDdl()

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

@@ -22,22 +22,47 @@ namespace Google.Cloud.Spanner.DataProvider.Tests;
 
 public class BatchTests : AbstractMockServerTests
 {
-    [TestCase(1, false)]
-    [TestCase(2, false)]
-    [TestCase(5, false)]
-    [TestCase(1, true)]
-    [TestCase(2, true)]
-    [TestCase(5, true)]
-    public async Task TestAllParameterTypes(int numCommands, bool executeAsync)
+    [TestCase(1, false, false)]
+    [TestCase(2, false, false)]
+    [TestCase(5, false, false)]
+    [TestCase(1, true, false)]
+    [TestCase(2, true, false)]
+    [TestCase(5, true, false)]
+    [TestCase(1, false, true)]
+    [TestCase(2, false, true)]
+    [TestCase(5, false, true)]
+    [TestCase(1, true, true)]
+    [TestCase(2, true, true)]
+    [TestCase(5, true, true)]
+    public async Task TestAllParameterTypes(int numCommands, bool executeAsync, bool useTransaction)
     {
         await using var connection = new SpannerConnection();
         connection.ConnectionString = ConnectionString;
         await connection.OpenAsync();
 
-        const string insert = "insert into my_table values (@p1, @p2, @p3, @p4, @p5, @p6, @p7, @p8, @p9, @p10, @p11, @p12)";
+        SpannerTransaction? transaction = null;
+        if (useTransaction)
+        {
+            if (executeAsync)
+            {
+                transaction = await connection.BeginTransactionAsync();
+            }
+            else
+            {
+                // ReSharper disable once MethodHasAsyncOverload
+                transaction = connection.BeginTransaction();
+            }
+        }
+
+        const string insert = "insert into my_table values " +
+                              "(@p1, @p2, @p3, @p4, @p5, @p6, @p7, @p8, @p9, @p10, @p11, @p12, @p13, @p14, @p15, @p16, @p17, @p18, @p19, @p20, @p21, @p22, @p23)";
         Fixture.SpannerMock.AddOrUpdateStatementResult(insert, StatementResult.CreateUpdateCount(1));
 
         await using var batch = connection.CreateBatch();
+        if (transaction != null)
+        {
+            batch.Transaction = transaction;
+        }
 
         for (var i = 0; i < numCommands; i++)
         {
@@ -90,6 +115,18 @@ public async Task TestAllParameterTypes(int numCommands, bool executeAsync)
         {
             Assert.That(command.RecordsAffected, Is.EqualTo(1));
         }
+        if (transaction != null)
+        {
+            if (executeAsync)
+            {
+                await transaction.CommitAsync();
+            }
+            else
+            {
+                // ReSharper disable once MethodHasAsyncOverload
+                transaction.Commit();
+            }
+        }
 
         var requests = Fixture.SpannerMock.Requests.ToList();
         Assert.That(requests.OfType<ExecuteBatchDmlRequest>().Count, Is.EqualTo(1));
@@ -196,6 +233,8 @@ public async Task TestAllParameterTypes(int numCommands, bool executeAsync)
             Assert.That(fields["p23"].ListValue.Values[0].NumberValue, Is.EqualTo(3.14f));
             Assert.That(fields["p23"].ListValue.Values[1].HasNullValue, Is.True);
         }
+        var commitRequest = requests.OfType<CommitRequest>().First();
+        Assert.That(commitRequest, Is.Not.Null);
     }
 
     [TestCase(true)]

drivers/spanner-ado-net/spanner-ado-net/SpannerDataReader.cs

@@ -19,6 +19,7 @@
 using System.Data.Common;
 using System.Globalization;
 using System.IO;
+using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
@@ -528,11 +529,21 @@ public override System.Type GetFieldType(int ordinal)
         return GetClrType(Metadata!.RowType.Fields[ordinal].Type);
     }
 
+    private static System.Type GetNullableClrType(Google.Cloud.Spanner.V1.Type type)
+    {
+        var clr = GetClrType(type);
+        if (clr.IsValueType)
+        {
+            return typeof(Nullable<>).MakeGenericType(clr);
+        }
+        return clr;
+    }
+
     private static System.Type GetClrType(Google.Cloud.Spanner.V1.Type type)
     {
         return type.Code switch
         {
-            TypeCode.Array => typeof(List<>).MakeGenericType(GetClrType(type.ArrayElementType)),
+            TypeCode.Array => typeof(List<>).MakeGenericType(GetNullableClrType(type.ArrayElementType)),
             TypeCode.Bool => typeof(bool),
             TypeCode.Bytes => typeof(byte[]),
             TypeCode.Date => typeof(DateOnly),
@@ -708,6 +719,10 @@ public override T GetFieldValue<T>(int ordinal)
         CheckNotClosed();
         CheckValidPosition();
         CheckValidOrdinal(ordinal);
+        if (typeof(T) == typeof(object))
+        {
+            return base.GetFieldValue<T>(ordinal);
+        }
         if (typeof(T) == typeof(Stream))
         {
             CheckNotNull(ordinal);
@@ -775,6 +790,15 @@ public override T GetFieldValue<T>(int ordinal)
             return (T)(object)GetInt64(ordinal);
         }
 
+        if (IsDBNull(ordinal) && default(T) == null)
+        {
+            if (typeof(T) == typeof(DBNull))
+            {
+                return (T)(object)DBNull.Value;
+            }
+            return (T)(object)null;
+        }
+
         return base.GetFieldValue<T>(ordinal);
     }
 
@@ -797,11 +821,20 @@ private static object GetUnderlyingValue(Google.Cloud.Spanner.V1.Type type, Valu
         switch (type.Code)
         {
             case TypeCode.Array:
-                var listType = typeof(List<>).MakeGenericType(GetClrType(type.ArrayElementType));
+                var listType = GetClrType(type);
                 var list = (IList)Activator.CreateInstance(listType);
+                if (list == null)
+                {
+                    throw new InvalidOperationException($"Failed to create instance of type {listType}.");
+                }
                 foreach (var element in value.ListValue.Values)
                 {
-                    list.Add(GetUnderlyingValue(type.ArrayElementType, element));
+                    var underlyingValue = GetUnderlyingValue(type.ArrayElementType, element);
+                    if (underlyingValue is DBNull)
+                    {
+                        underlyingValue = null;
+                    }
+                    list.Add(underlyingValue);
                 }
                 return list;
             case TypeCode.Bool:

spannerlib/wrappers/spannerlib-dotnet/spannerlib-dotnet-mockserver/RandomResultSetGenerator.cs

@@ -57,12 +57,12 @@ public static StructType GenerateAllTypesRowType()
         };
     }
 
-    public static ResultSet Generate(int numRows)
+    public static ResultSet Generate(int numRows, bool allowNull = false)
     {
-        return Generate(GenerateAllTypesRowType(), numRows);
+        return Generate(GenerateAllTypesRowType(), numRows, allowNull);
     }
 
-    public static ResultSet Generate(StructType rowType, int numRows)
+    public static ResultSet Generate(StructType rowType, int numRows, bool allowNull = false)
     {
         var result = new ResultSet
         {
@@ -73,23 +73,27 @@ public static ResultSet Generate(StructType rowType, int numRows)
         };
         for (var i = 0; i < numRows; i++)
         {
-            result.Rows.Add(GenerateRow(rowType));
+            result.Rows.Add(GenerateRow(rowType, allowNull));
         }
         return result;
     }
 
-    private static ListValue GenerateRow(StructType rowType)
+    private static ListValue GenerateRow(StructType rowType, bool allowNull)
     {
         var row = new ListValue();
         foreach (var field in rowType.Fields)
         {
-            row.Values.Add(GenerateValue(field.Type));
+            row.Values.Add(GenerateValue(field.Type, allowNull));
         }
         return row;
     }
 
-    private static Value GenerateValue(Spanner.V1.Type type)
+    private static Value GenerateValue(Spanner.V1.Type type, bool allowNull)
     {
+        if (allowNull && Random.Shared.Next(10) == 5)
+        {
+            return Value.ForNull();
+        }
         switch (type.Code)
         {
             case TypeCode.Bool:
@@ -106,7 +110,7 @@ private static Value GenerateValue(Spanner.V1.Type type)
             case TypeCode.Float64:
                 return Value.ForNumber(Random.Shared.NextDouble() * double.MaxValue);
             case TypeCode.Int64:
-                return Value.ForNumber(Random.Shared.NextInt64());
+                return Value.ForString(Random.Shared.NextInt64().ToString());
             case TypeCode.Interval:
                 var timespan = TimeSpan.FromTicks(Random.Shared.NextInt64());
                 return Value.ForString(XmlConvert.ToString(timespan));
@@ -129,7 +133,7 @@ private static Value GenerateValue(Spanner.V1.Type type)
                 var values = new Value[length];
                 for (var i = 0; i < length; i++)
                 {
-                    values[i] = GenerateValue(type.ArrayElementType);
+                    values[i] = GenerateValue(type.ArrayElementType, allowNull);
                 }
                 return Value.ForList(values);
             default: