Added public method ExecuteScalarAsync<T>

Author: fixer-m

Diff for: Snowflake.Client.Tests/IntegrationTests/SnowflakeQueriesTest.cs

@@ -7,36 +7,60 @@ namespace Snowflake.Client.Tests.IntegrationTests
     public class SnowflakeQueriesTest : IntegrationTestBase
     {
         [Test]
-        public async Task ExecuteScalar_WithResult()
+        public async Task ExecuteScalar_String()
         {
             var result = await _snowflakeClient.ExecuteScalarAsync("SELECT CURRENT_USER();");
-
             Assert.IsTrue(!string.IsNullOrWhiteSpace(result));
         }
 
         [Test]
         public async Task ExecuteScalar_Null()
         {
             var result = await _snowflakeClient.ExecuteScalarAsync("SELECT 1 WHERE 2 > 3;");
-
+            Assert.IsNull(result);
+        }
+        
+        [Test]
+        public async Task ExecuteScalar_Number()
+        {
+            var result = await _snowflakeClient.ExecuteScalarAsync("SELECT 1;");
+            Assert.AreEqual("1", result);
+        }
+        
+        [Test]
+        public async Task ExecuteScalar_Typed_String()
+        {
+            var result = await _snowflakeClient.ExecuteScalarAsync<string>("SELECT CURRENT_USER();");
+            Assert.IsTrue(!string.IsNullOrWhiteSpace(result));
+        }
+        
+        [Test]
+        public async Task ExecuteScalar_Typed_Null()
+        {
+            var result = await _snowflakeClient.ExecuteScalarAsync<string>("SELECT 1 WHERE 2 > 3;");
             Assert.IsNull(result);
         }
 
+        [Test]
+        public async Task ExecuteScalar_Typed_Number()
+        {
+            var result = await _snowflakeClient.ExecuteScalarAsync<int>("SELECT 1;");
+            Assert.AreEqual(1, result);
+        }
+        
         [Test]
         public async Task Execute()
         {
             // todo: do temporary insert to get affected rows > 0
 
-            var result = await _snowflakeClient.ExecuteAsync("SELECT 1;");
-
-            Assert.IsTrue(result == -1);
+            var affectedRows = await _snowflakeClient.ExecuteAsync("SELECT 1;");
+            Assert.AreEqual(-1, affectedRows);
         }
 
         [Test]
         public async Task QueryRawResponse()
         {
             var result = await _snowflakeClient.QueryRawResponseAsync("SELECT CURRENT_USER();");
-
             Assert.IsNotNull(result);
         }
     }

Diff for: Snowflake.Client.Tests/UnitTests/SnowflakeDataMapperTests.cs

@@ -11,49 +11,186 @@ namespace Snowflake.Client.Tests.UnitTests
     public class SnowflakeDataMapperTests
     {
         [Test]
-        public void SnowflakeDataMapper_MapTo_CustomClass()
+        public void ResponseWithValues_MapTo_CustomClass()
         {
             var responseSample = GetFakeResponse();
+            var firstObjectRowset = new List<List<string>>() { responseSample.RowSet[0] };
+            var mappedObjects = SnowflakeDataMapper.MapTo<CustomClass>(responseSample.RowType, firstObjectRowset);
+            var mappedObject = mappedObjects.FirstOrDefault();
 
-            var mappedObjects = SnowflakeDataMapper.MapTo<CustomClass>(responseSample.RowType, responseSample.RowSet);
-            var firstObject = mappedObjects.FirstOrDefault();
-
-            Assert.IsNotNull(firstObject);
-            Assert.AreEqual("Sometext", firstObject.StringProperty);
-            Assert.AreEqual(true, firstObject.BoolProperty);
-            Assert.AreEqual(7, firstObject.IntProperty);
-            Assert.AreEqual(27.6F, firstObject.FloatProperty);
-            Assert.AreEqual(19.239834M, firstObject.DecimalProperty);
-            Assert.AreEqual(Guid.Parse("e7412bbf-88ee-4149-b341-101e0f72ec7c"), firstObject.GuidProperty);
-            Assert.AreEqual(new byte[] { 0, 128, 255 }, firstObject.ByteArrayProperty);
+            Assert.IsNotNull(mappedObject);
+            Assert.AreEqual("Sometext", mappedObject.StringProperty);
+            Assert.AreEqual(true, mappedObject.BoolProperty);
+            Assert.AreEqual(7, mappedObject.IntProperty);
+            Assert.AreEqual(27.6F, mappedObject.FloatProperty);
+            Assert.AreEqual(19.239834M, mappedObject.DecimalProperty);
+            Assert.AreEqual(Guid.Parse("e7412bbf-88ee-4149-b341-101e0f72ec7c"), mappedObject.GuidProperty);
+            Assert.AreEqual(new byte[] { 0, 128, 255 }, mappedObject.ByteArrayProperty);
 
             var dateTime = DateTime.ParseExact("2020-09-13 12:26:40.0000000", "yyyy-MM-dd HH:mm:ss.fffffff", CultureInfo.InvariantCulture);
-            Assert.AreEqual(dateTime, firstObject.DateTimeProperty);
+            Assert.AreEqual(dateTime, mappedObject.DateTimeProperty);
 
             var dateTimeOffset = DateTimeOffset.ParseExact("2020-09-13 12:26:40.0000000", "yyyy-MM-dd HH:mm:ss.fffffff", CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal);
-            Assert.AreEqual(dateTimeOffset, firstObject.DateTimeOffsetProperty);
+            Assert.AreEqual(dateTimeOffset, mappedObject.DateTimeOffsetProperty);
         }
 
         [Test]
-        public void SnowflakeDataMapper_MapTo_CustomClassWithNullableProps()
+        public void ResponseWithValues_MapTo_CustomClassWithNullableProps()
         {
             var responseSample = GetFakeResponse();
+            var firstObjectRowset = new List<List<string>>() { responseSample.RowSet[0] };
+            var mappedObjects = SnowflakeDataMapper.MapTo<CustomClassNullables>(responseSample.RowType, firstObjectRowset);
+            var mappedObject = mappedObjects.FirstOrDefault();
 
-            var mappedObjects = SnowflakeDataMapper.MapTo<CustomClassNullables>(responseSample.RowType, responseSample.RowSet);
-            var firstObject = mappedObjects.FirstOrDefault();
-
-            Assert.IsNotNull(firstObject);
-            Assert.AreEqual(true, firstObject.BoolProperty);
-            Assert.AreEqual(7, firstObject.IntProperty);
-            Assert.AreEqual(27.6F, firstObject.FloatProperty);
-            Assert.AreEqual(19.239834M, firstObject.DecimalProperty);
-            Assert.AreEqual(Guid.Parse("e7412bbf-88ee-4149-b341-101e0f72ec7c"), firstObject.GuidProperty);
+            Assert.IsNotNull(mappedObject);
+            Assert.AreEqual(true, mappedObject.BoolProperty);
+            Assert.AreEqual(7, mappedObject.IntProperty);
+            Assert.AreEqual(27.6F, mappedObject.FloatProperty);
+            Assert.AreEqual(19.239834M, mappedObject.DecimalProperty);
+            Assert.AreEqual(Guid.Parse("e7412bbf-88ee-4149-b341-101e0f72ec7c"), mappedObject.GuidProperty);
 
             var dateTime = DateTime.ParseExact("2020-09-13 12:26:40.0000000", "yyyy-MM-dd HH:mm:ss.fffffff", CultureInfo.InvariantCulture);
-            Assert.AreEqual(dateTime, firstObject.DateTimeProperty);
+            Assert.AreEqual(dateTime, mappedObject.DateTimeProperty);
 
             var dateTimeOffset = DateTimeOffset.ParseExact("2020-09-13 12:26:40.0000000", "yyyy-MM-dd HH:mm:ss.fffffff", CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal);
-            Assert.AreEqual(dateTimeOffset, firstObject.DateTimeOffsetProperty);
+            Assert.AreEqual(dateTimeOffset, mappedObject.DateTimeOffsetProperty);
+        }
+
+        [Test]
+        public void ResponseWithStringNull_MapTo_CustomClassWithNullables()
+        {
+            var responseSample = GetFakeResponse();
+
+            var firstObjectRowset = new List<List<string>>() { responseSample.RowSet[1] };
+            var mappedObjects = SnowflakeDataMapper.MapTo<CustomClassNullables>(responseSample.RowType, firstObjectRowset);
+            var mappedObject = mappedObjects.FirstOrDefault();
+
+            Assert.IsNotNull(mappedObject);
+            Assert.AreEqual(null, mappedObject.StringProperty);
+            Assert.AreEqual(null, mappedObject.BoolProperty);
+            Assert.AreEqual(null, mappedObject.IntProperty);
+            Assert.AreEqual(null, mappedObject.FloatProperty);
+            Assert.AreEqual(null, mappedObject.DecimalProperty);
+            Assert.AreEqual(null, mappedObject.GuidProperty);
+            Assert.AreEqual(null, mappedObject.DateTimeProperty);
+            Assert.AreEqual(null, mappedObject.DateTimeOffsetProperty);
+            Assert.AreEqual(null, mappedObject.ByteArrayProperty);
+        }
+
+        [Test]
+        public void ResponseWithNull_MapTo_CustomClassWithNullables()
+        {
+            var responseSample = GetFakeResponse();
+
+            var firstObjectRowset = new List<List<string>>() { responseSample.RowSet[2] };
+            var mappedObjects = SnowflakeDataMapper.MapTo<CustomClassNullables>(responseSample.RowType, firstObjectRowset);
+            var mappedObject = mappedObjects.FirstOrDefault();
+
+            Assert.IsNotNull(mappedObject);
+            Assert.AreEqual(null, mappedObject.StringProperty);
+            Assert.AreEqual(null, mappedObject.BoolProperty);
+            Assert.AreEqual(null, mappedObject.IntProperty);
+            Assert.AreEqual(null, mappedObject.FloatProperty);
+            Assert.AreEqual(null, mappedObject.DecimalProperty);
+            Assert.AreEqual(null, mappedObject.GuidProperty);
+            Assert.AreEqual(null, mappedObject.DateTimeProperty);
+            Assert.AreEqual(null, mappedObject.DateTimeOffsetProperty);
+            Assert.AreEqual(null, mappedObject.ByteArrayProperty);
+        }
+
+        [Test]
+        public void ResponseWithValues_MapTo_SingleValue()
+        {
+            var responseSample = GetFakeResponse();
+            var rowSet = responseSample.RowSet[0];
+            var rowType = responseSample.RowType;
+
+            var stringValue = SnowflakeDataMapper.MapTo<string>(rowType[0], rowSet[0]);
+            Assert.AreEqual("Sometext", stringValue);
+
+            var boolValue = SnowflakeDataMapper.MapTo<bool>(rowType[1], rowSet[1]);
+            Assert.AreEqual(true, boolValue);
+
+            var intValue = SnowflakeDataMapper.MapTo<int>(rowType[2], rowSet[2]);
+            Assert.AreEqual(7, intValue);
+
+            var floatValue = SnowflakeDataMapper.MapTo<float>(rowType[3], rowSet[3]);
+            Assert.AreEqual(27.6F, floatValue);
+
+            var decimalValue = SnowflakeDataMapper.MapTo<decimal>(rowType[4], rowSet[4]);
+            Assert.AreEqual(19.239834M, decimalValue);
+
+            var dateTimeExpected = DateTime.ParseExact("2020-09-13 12:26:40.0000000", "yyyy-MM-dd HH:mm:ss.fffffff", CultureInfo.InvariantCulture);
+            var dateTimeValue = SnowflakeDataMapper.MapTo<DateTime>(rowType[5], rowSet[5]);
+            Assert.AreEqual(dateTimeExpected, dateTimeValue);
+
+            var dateTimeOffsetExpected = DateTimeOffset.ParseExact("2020-09-13 12:26:40.0000000", "yyyy-MM-dd HH:mm:ss.fffffff", CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal);
+            var dateTimeOffsetValue = SnowflakeDataMapper.MapTo<DateTimeOffset>(rowType[6], rowSet[6]);
+            Assert.AreEqual(dateTimeOffsetExpected, dateTimeOffsetValue);
+
+            var guidValue = SnowflakeDataMapper.MapTo<Guid>(rowType[7], rowSet[7]);
+            Assert.AreEqual(Guid.Parse("e7412bbf-88ee-4149-b341-101e0f72ec7c"), guidValue);
+
+            var bytesValues = SnowflakeDataMapper.MapTo<byte[]>(rowType[8], rowSet[8]);
+            Assert.AreEqual(new byte[] { 0, 128, 255 }, bytesValues);
+        }
+
+        [Test]
+        public void ResponseWithStringNull_MapTo_SingleValueNullable()
+        {
+            var responseSample = GetFakeResponse();
+            var rowSet = responseSample.RowSet[1];
+            var rowType = responseSample.RowType;
+
+            var boolValue = SnowflakeDataMapper.MapTo<bool?>(rowType[1], rowSet[1]);
+            Assert.AreEqual(null, boolValue);
+
+            var intValue = SnowflakeDataMapper.MapTo<int?>(rowType[2], rowSet[2]);
+            Assert.AreEqual(null, intValue);
+
+            var floatValue = SnowflakeDataMapper.MapTo<float?>(rowType[3], rowSet[3]);
+            Assert.AreEqual(null, floatValue);
+
+            var decimalValue = SnowflakeDataMapper.MapTo<decimal?>(rowType[4], rowSet[4]);
+            Assert.AreEqual(null, decimalValue);
+
+            var dateTimeValue = SnowflakeDataMapper.MapTo<DateTime?>(rowType[5], rowSet[5]);
+            Assert.AreEqual(null, dateTimeValue);
+
+            var dateTimeOffsetValue = SnowflakeDataMapper.MapTo<DateTimeOffset?>(rowType[6], rowSet[6]);
+            Assert.AreEqual(null, dateTimeOffsetValue);
+
+            var guidValue = SnowflakeDataMapper.MapTo<Guid?>(rowType[7], rowSet[7]);
+            Assert.AreEqual(null, guidValue);
+        }
+
+        [Test]
+        public void ResponseWithNull_MapTo_SingleValueNullable()
+        {
+            var responseSample = GetFakeResponse();
+            var rowSet = responseSample.RowSet[2];
+            var rowType = responseSample.RowType;
+
+            var boolValue = SnowflakeDataMapper.MapTo<bool?>(rowType[1], rowSet[1]);
+            Assert.AreEqual(null, boolValue);
+
+            var intValue = SnowflakeDataMapper.MapTo<int?>(rowType[2], rowSet[2]);
+            Assert.AreEqual(null, intValue);
+
+            var floatValue = SnowflakeDataMapper.MapTo<float?>(rowType[3], rowSet[3]);
+            Assert.AreEqual(null, floatValue);
+
+            var decimalValue = SnowflakeDataMapper.MapTo<decimal?>(rowType[4], rowSet[4]);
+            Assert.AreEqual(null, decimalValue);
+
+            var dateTimeValue = SnowflakeDataMapper.MapTo<DateTime?>(rowType[5], rowSet[5]);
+            Assert.AreEqual(null, dateTimeValue);
+
+            var dateTimeOffsetValue = SnowflakeDataMapper.MapTo<DateTimeOffset?>(rowType[6], rowSet[6]);
+            Assert.AreEqual(null, dateTimeOffsetValue);
+
+            var guidValue = SnowflakeDataMapper.MapTo<Guid?>(rowType[7], rowSet[7]);
+            Assert.AreEqual(null, guidValue);
         }
 
         private QueryExecResponseData GetFakeResponse()
@@ -70,7 +207,8 @@ private QueryExecResponseData GetFakeResponse()
             response.RowType.Add(new ColumnDescription() { Name = "GuidProperty", Type = "text" });
             response.RowType.Add(new ColumnDescription() { Name = "ByteArrayProperty", Type = "binary" });
 
-            response.RowSet.Add(new List<string>() {
+            response.RowSet.Add(new List<string>()
+            {
                 "Sometext",
                 "true",
                 "7",
@@ -82,6 +220,33 @@ private QueryExecResponseData GetFakeResponse()
                 "0080ff"
             });
 
+            response.RowSet.Add(new List<string>()
+            {
+                "null",
+                "null",
+                "null",
+                "null",
+                "null",
+                "null",
+                "null",
+                "null",
+                "null"
+            });
+
+
+            response.RowSet.Add(new List<string>()
+            {
+                null,
+                null,
+                null,
+                null,
+                null,
+                null,
+                null,
+                null,
+                null
+            });
+
             return response;
         }
 
@@ -108,6 +273,8 @@ private class CustomClass
 
         private class CustomClassNullables
         {
+            public string StringProperty { get; set; }
+
             public bool? BoolProperty { get; set; }
 
             public int? IntProperty { get; set; }
@@ -121,6 +288,8 @@ private class CustomClassNullables
             public DateTimeOffset? DateTimeOffsetProperty { get; set; }
 
             public Guid? GuidProperty { get; set; }
+
+            public byte[] ByteArrayProperty { get; set; }
         }
     }
-}
+}

Diff for: Snowflake.Client/SnowflakeClient.cs

@@ -146,6 +146,23 @@ public async Task<string> ExecuteScalarAsync(string sql, object sqlParams = null
             return rawResult;
         }
 
+        /// <summary>
+        /// Execute SQL that selects a single value.
+        /// </summary>
+        /// <param name="sql">The SQL to execute.</param>
+        /// <param name="sqlParams">The parameters to use for this command.</param>
+        /// <returns>The first cell value returned as of type T.</returns>
+        public async Task<T> ExecuteScalarAsync<T>(string sql, object sqlParams = null, CancellationToken ct = default)
+        {
+            var response = await QueryInternalAsync(sql, sqlParams, false, ct).ConfigureAwait(false);
+
+            var firstColumn = response.Data.RowType.FirstOrDefault();
+            var firstColumnValue = response.Data.RowSet.FirstOrDefault()?.FirstOrDefault();
+
+            var result = SnowflakeDataMapper.MapTo<T>(firstColumn, firstColumnValue);
+            return result;
+        }
+
         /// <summary>
         /// Execute parameterized SQL.
         /// </summary>

Diff for: Snowflake.Client/SnowflakeDataMapper.cs

@@ -21,6 +21,15 @@ public static void SetJsonMapperOptions(JsonSerializerOptions jsonMapperOptions)
             Configure(jsonMapperOptions);
         }
 
+        public static T MapTo<T>(ColumnDescription column, string value)
+        {
+            if (column == null)
+                throw new ArgumentNullException(nameof(column));
+
+            var jsonToken = ConvertColumnValueToJsonToken(value, column.Type);
+            return JsonSerializer.Deserialize<T>(jsonToken, _jsonMapperOptions);
+        }
+
         public static IEnumerable<T> MapTo<T>(List<ColumnDescription> columns, List<List<string>> rows)
         {
             if (columns == null || columns.Count == 0)