fix(spanner): honor IDataRecord.GetOrdinal lookup rules

apis/Google.Cloud.Spanner.Data/Google.Cloud.Spanner.Data.Tests/SpannerDataReaderTests.cs

@@ -19,6 +19,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using Xunit;
 using TypeCode = Google.Cloud.Spanner.V1.TypeCode;
 
@@ -130,6 +131,39 @@ public void GetBytes_WrongType()
             Assert.Throws<ArgumentException>(() => reader.GetBytes(0, 0L, null, 0, 0));
         }
 
+        [Fact]
+        public async Task GetOrdinal_CaseInsensitiveFallback()
+        {
+            var reader = CreateSpannerDataReader(
+                new[] { CreateResultSet(new[] { Value.ForString("value") }) },
+                CreateMetadata("id"));
+
+            Assert.Equal(0, reader.GetOrdinal("Id"));
+            Assert.Equal(0, await reader.GetOrdinalAsync("ID"));
+        }
+
+        [Fact]
+        public void GetOrdinal_ExactCaseMatchPrecedesFallback()
+        {
+            var reader = CreateSpannerDataReader(
+                new[] { CreateResultSet(new[] { Value.ForString("lower"), Value.ForString("upper") }) },
+                CreateMetadata("id", "ID"));
+
+            Assert.Equal(1, reader.GetOrdinal("ID"));
+            Assert.Equal(0, reader.GetOrdinal("Id"));
+        }
+
+        [Fact]
+        public async Task GetOrdinal_UnknownColumnThrowsIndexOutOfRangeException()
+        {
+            var reader = CreateSpannerDataReader(
+                new[] { CreateResultSet(new[] { Value.ForString("value") }) },
+                CreateMetadata("id"));
+
+            Assert.Throws<IndexOutOfRangeException>(() => reader.GetOrdinal("missing"));
+            await Assert.ThrowsAsync<IndexOutOfRangeException>(() => reader.GetOrdinalAsync("missing"));
+        }
+
         private static SpannerDataReader CreateTestReader(byte[] bytes)
         {
             var results = new []
@@ -175,5 +209,22 @@ private static ResultSetMetadata CreateSingleFieldMetadata(TypeCode typeCode) =>
                     }
                 }
             };
+
+        private static ResultSetMetadata CreateMetadata(params string[] fieldNames) =>
+            new ResultSetMetadata
+            {
+                RowType = new StructType
+                {
+                    Fields =
+                    {
+                        fieldNames.Select(name => new StructType.Types.Field
+                        {
+                            Name = name,
+                            Type = new V1.Type { Code = TypeCode.String }
+                        })
+                    }
+                }
+            };
+
     }
 }

apis/Google.Cloud.Spanner.Data/Google.Cloud.Spanner.Data/SpannerDataReader.cs

@@ -285,7 +285,7 @@ public override int GetOrdinal(string name)
                 PopulateMetadata();
                 InitializeFieldIndexFromMetadata();
             }
-            return _fieldIndex[name];
+            return GetOrdinalFromFieldIndex(name);
         }
 
         /// <summary>
@@ -303,7 +303,26 @@ public async Task<int> GetOrdinalAsync(string name, CancellationToken cancellati
                 await PopulateMetadataAsync(cancellationToken).ConfigureAwait(false);
                 InitializeFieldIndexFromMetadata();
             }
-            return _fieldIndex[name];
+            return GetOrdinalFromFieldIndex(name);
+        }
+
+        private int GetOrdinalFromFieldIndex(string name)
+        {
+            if (_fieldIndex.TryGetValue(name, out int ordinal))
+            {
+                return ordinal;
+            }
+
+            var fields = _metadata.RowType.Fields;
+            for (int i = 0; i < fields.Count; i++)
+            {
+                if (string.Equals(fields[i].Name, name, StringComparison.OrdinalIgnoreCase))
+                {
+                    return i;
+                }
+            }
+
+            throw new IndexOutOfRangeException($"Column '{name}' was not found.");
         }
 
         /// <summary>