feat: implement comprehensive data type support for RPC parameters

Author: vkuttyp

Directory.Build.props

@@ -7,6 +7,6 @@
     <Authors>vkuttyp</Authors>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <RepositoryUrl>https://github.com/vkuttyp/CosmoSQLClient-Dotnet</RepositoryUrl>
-    <Version>1.9.6</Version>
+    <Version>1.9.7</Version>
   </PropertyGroup>
 </Project>

src/CosmoSQLClient.Core/SqlValue.cs

@@ -41,8 +41,10 @@ public sealed record Date(DateTime Value) : SqlValue;
     private static SqlValue FromBoxed(object v) => v switch
     {
         bool b      => From(b),
-        sbyte b     => From(b),
-        short s     => From(s),
+        byte b      => From((int)b),
+        sbyte b     => From((int)b),
+        ushort s    => From((int)s),
+        short s     => From((int)s),
         int i       => From(i),
         long l      => From(l),
         float f     => From(f),

src/CosmoSQLClient.MsSql/MsSqlConnection.cs

@@ -500,7 +500,8 @@ private static string BuildParamDeclarations(IReadOnlyList<SqlParameter> paramet
     private static string SqlValueToTypeName(SqlValue v) => v switch {
         SqlValue.Bool => "BIT", SqlValue.Int32 => "INT", SqlValue.Int64 => "BIGINT",
         SqlValue.Float => "REAL", SqlValue.Double => "FLOAT", SqlValue.Decimal => "DECIMAL(38,10)",
-        SqlValue.Date => "DATETIME", SqlValue.Uuid => "UNIQUEIDENTIFIER", _ => "NVARCHAR(MAX)"
+        SqlValue.Date => "DATETIME", SqlValue.Uuid => "UNIQUEIDENTIFIER", SqlValue.Bytes => "VARBINARY(MAX)",
+        _ => "NVARCHAR(MAX)"
     };
 
     private static void WriteAllHeaders(BinaryWriter bw, long tx) {
@@ -561,9 +562,15 @@ private static void WriteNamedParam(BinaryWriter bw, string name, SqlValue value
                 break;
             case SqlValue.Uuid v:
                 bw.Write((byte)0x24); // UNIQUEIDENTIFIER
-                bw.Write((byte)0x10); // length
+                bw.Write((byte)0x10); // Max length
+                bw.Write((byte)0x10); // Actual data length
                 bw.Write(v.Value.ToByteArray());
                 break;
+            case SqlValue.Bytes v:
+                bw.Write((byte)0xA5); // VARBINARY
+                bw.Write((ushort)0xFFFF); // Max length (PLP)
+                WritePlpBytes(bw, v.Value);
+                break;
             default:
                 WriteNvarcharMaxTypeAndValue(bw, value.AsString());
                 break;
@@ -579,4 +586,11 @@ private static void WriteNvarcharMaxTypeAndValue(BinaryWriter bw, string? s) {
             bw.Write((ulong)b.Length); bw.Write((uint)b.Length); bw.Write(b); bw.Write((uint)0);
         }
     }
+
+    private static void WritePlpBytes(BinaryWriter bw, byte[]? b) {
+        if (b == null) bw.Write(ulong.MaxValue);
+        else {
+            bw.Write((ulong)b.Length); bw.Write((uint)b.Length); bw.Write(b); bw.Write((uint)0);
+        }
+    }
 }

tests/CosmoSQLClient.MsSql.Tests/AdoNetTests.cs

@@ -147,6 +147,71 @@ public async Task StandardAdoNet_DateTimeParameter_ShouldWork()
         Assert.Equal(now, (DateTime)result!);
     }
 
+    [Fact]
+    public async Task StandardAdoNet_AllDataTypes_ShouldWork()
+    {
+        if (ShouldSkip) return;
+
+        using var conn = new MsSqlConnection(ConnectionString);
+        await conn.OpenAsync();
+
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = @"
+            SELECT 
+                @p_bool AS v_bool,
+                @p_byte AS v_byte,
+                @p_short AS v_short,
+                @p_int AS v_int,
+                @p_long AS v_long,
+                @p_float AS v_float,
+                @p_double AS v_double,
+                @p_decimal AS v_decimal,
+                @p_string AS v_string,
+                @p_guid AS v_guid,
+                @p_date AS v_date,
+                @p_bin AS v_bin,
+                @p_null AS v_null";
+
+        var guid = Guid.NewGuid();
+        var date = new DateTime(2023, 12, 25, 10, 30, 0);
+        var bin = new byte[] { 0xDE, 0xAD, 0xBE, 0xEF };
+
+        cmd.Parameters.AddWithValue("p_bool", true);
+        cmd.Parameters.AddWithValue("p_byte", (byte)255);
+        cmd.Parameters.AddWithValue("p_short", (short)32767);
+        cmd.Parameters.AddWithValue("p_int", 123456789);
+        cmd.Parameters.AddWithValue("p_long", 9876543210L);
+        cmd.Parameters.AddWithValue("p_float", 1.23f);
+        cmd.Parameters.AddWithValue("p_double", 4.5678);
+        cmd.Parameters.AddWithValue("p_decimal", 12345.6789m);
+        cmd.Parameters.AddWithValue("p_string", "Hello Comprehensive Test");
+        cmd.Parameters.AddWithValue("p_guid", guid);
+        cmd.Parameters.AddWithValue("p_date", date);
+        cmd.Parameters.AddWithValue("p_bin", bin);
+        cmd.Parameters.AddWithValue("p_null", DBNull.Value);
+
+        using var reader = await cmd.ExecuteReaderAsync();
+        Assert.True(await reader.ReadAsync());
+
+        Assert.True(reader.GetBoolean(0));
+        Assert.Equal(255, reader.GetInt32(1)); 
+        Assert.Equal((short)32767, reader.GetInt16(2));
+        Assert.Equal(123456789, reader.GetInt32(3));
+        Assert.Equal(9876543210L, reader.GetInt64(4));
+        Assert.Equal(1.23f, reader.GetFloat(5));
+        Assert.Equal(4.5678, reader.GetDouble(6));
+        Assert.Equal(12345.6789m, reader.GetDecimal(7));
+        Assert.Equal("Hello Comprehensive Test", reader.GetString(8));
+        Assert.Equal(guid, reader.GetGuid(9));
+        Assert.Equal(date, reader.GetDateTime(10));
+        
+        var actualBin = new byte[4];
+        reader.GetBytes(11, 0, actualBin, 0, 4);
+        Assert.Equal(bin, actualBin);
+        
+        Assert.True(await reader.IsDBNullAsync(12));
+    }
+
     [Fact]
     public async Task StandardAdoNet_Transactions_ShouldWork()
     {