Testing for query strings and various type mapping fixes (#29051)

src/EFCore.SqlServer/Query/Internal/SqlServerQueryStringFactory.cs

@@ -116,12 +116,25 @@ private static StringBuilder AppendPrecision(this StringBuilder builder, DbParam
         return builder;
     }
 
+    private static StringBuilder AppendScale(this StringBuilder builder, DbParameter parameter)
+    {
+        if (parameter.Scale > 0)
+        {
+            builder
+                .Append('(')
+                .Append(parameter.Scale.ToString(CultureInfo.InvariantCulture))
+                .Append(')');
+        }
+
+        return builder;
+    }
+
     private static StringBuilder AppendPrecisionAndScale(this StringBuilder builder, DbParameter parameter)
     {
         if (parameter.Precision > 0
             && parameter.Scale > 0)
         {
-            builder
+            return builder
                 .Append('(')
                 .Append(parameter.Precision.ToString(CultureInfo.InvariantCulture))
                 .Append(',')
@@ -161,7 +174,7 @@ public static string CreateTypeName(DbParameter parameter)
                 SqlDbType.SmallMoney => builder.Append("smallmoney"),
                 SqlDbType.Structured => builder.Append("structured"),
                 SqlDbType.Text => builder.Append("text"),
-                SqlDbType.Time => builder.Append("time").AppendPrecision(parameter),
+                SqlDbType.Time => builder.Append("time").AppendScale(parameter),
                 SqlDbType.Timestamp => builder.Append("rowversion"),
                 SqlDbType.TinyInt => builder.Append("tinyint"),
                 SqlDbType.Udt => builder.Append(sqlParameter.UdtTypeName),

src/EFCore.SqlServer/Storage/Internal/SqlServerDateTimeTypeMapping.cs

@@ -18,6 +18,8 @@ public class SqlServerDateTimeTypeMapping : DateTimeTypeMapping
     private const string SmallDateTimeFormatConst = "'{0:yyyy-MM-ddTHH:mm:ss}'";
     private const string DateTimeFormatConst = "'{0:yyyy-MM-ddTHH:mm:ss.fff}'";
 
+    private readonly SqlDbType? _sqlDbType;
+
     // Note: this array will be accessed using the precision as an index
     // so the order of the entries in this array is important
     private readonly string[] _dateTime2Formats =
@@ -41,13 +43,15 @@ public class SqlServerDateTimeTypeMapping : DateTimeTypeMapping
     public SqlServerDateTimeTypeMapping(
         string storeType,
         DbType? dbType = System.Data.DbType.DateTime2,
+        SqlDbType? sqlDbType = null,
         StoreTypePostfix storeTypePostfix = StoreTypePostfix.Precision)
-        : base(
+        : this(
             new RelationalTypeMappingParameters(
                 new CoreTypeMappingParameters(typeof(DateTime)),
                 storeType,
                 storeTypePostfix,
-                dbType))
+                dbType),
+            sqlDbType)
     {
     }
 
@@ -57,11 +61,21 @@ public SqlServerDateTimeTypeMapping(
     ///     any release. You should only use it directly in your code with extreme caution and knowing that
     ///     doing so can result in application failures when updating to a new Entity Framework Core release.
     /// </summary>
-    protected SqlServerDateTimeTypeMapping(RelationalTypeMappingParameters parameters)
+    protected SqlServerDateTimeTypeMapping(RelationalTypeMappingParameters parameters, SqlDbType? sqlDbType)
         : base(parameters)
     {
+        _sqlDbType = sqlDbType;
     }
 
+    /// <summary>
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+    /// </summary>
+    public virtual SqlDbType? SqlType
+        => _sqlDbType;
+
     /// <summary>
     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
     ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
@@ -72,9 +86,13 @@ protected override void ConfigureParameter(DbParameter parameter)
     {
         base.ConfigureParameter(parameter);
 
-        // Workaround for a SQLClient bug
-        if (DbType == System.Data.DbType.Date)
+        if (_sqlDbType != null)
+        {
+            ((SqlParameter)parameter).SqlDbType = _sqlDbType.Value;
+        }
+        else if (DbType == System.Data.DbType.Date)
         {
+            // Workaround for a SQLClient bug
             ((SqlParameter)parameter).SqlDbType = SqlDbType.Date;
         }
 
@@ -97,7 +115,7 @@ protected override void ConfigureParameter(DbParameter parameter)
     /// <param name="parameters">The parameters for this mapping.</param>
     /// <returns>The newly created mapping.</returns>
     protected override RelationalTypeMapping Clone(RelationalTypeMappingParameters parameters)
-        => new SqlServerDateTimeTypeMapping(parameters);
+        => new SqlServerDateTimeTypeMapping(parameters, _sqlDbType);
 
     /// <summary>
     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to

src/EFCore.SqlServer/Storage/Internal/SqlServerDecimalTypeMapping.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Data;
+using Microsoft.Data.SqlClient;
 
 namespace Microsoft.EntityFrameworkCore.SqlServer.Storage.Internal;
 
@@ -13,6 +14,8 @@ namespace Microsoft.EntityFrameworkCore.SqlServer.Storage.Internal;
 /// </summary>
 public class SqlServerDecimalTypeMapping : DecimalTypeMapping
 {
+    private readonly SqlDbType? _sqlDbType;
+
     /// <summary>
     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
     ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
@@ -24,14 +27,15 @@ public SqlServerDecimalTypeMapping(
         DbType? dbType = System.Data.DbType.Decimal,
         int? precision = null,
         int? scale = null,
+        SqlDbType? sqlDbType = null,
         StoreTypePostfix storeTypePostfix = StoreTypePostfix.PrecisionAndScale)
-        : base(
+        : this(
             new RelationalTypeMappingParameters(
                     new CoreTypeMappingParameters(typeof(decimal)),
                     storeType,
                     storeTypePostfix,
                     dbType)
-                .WithPrecisionAndScale(precision, scale))
+                .WithPrecisionAndScale(precision, scale), sqlDbType)
     {
     }
 
@@ -41,19 +45,29 @@ public SqlServerDecimalTypeMapping(
     ///     any release. You should only use it directly in your code with extreme caution and knowing that
     ///     doing so can result in application failures when updating to a new Entity Framework Core release.
     /// </summary>
-    protected SqlServerDecimalTypeMapping(RelationalTypeMappingParameters parameters)
+    protected SqlServerDecimalTypeMapping(RelationalTypeMappingParameters parameters, SqlDbType? sqlDbType)
         : base(parameters)
     {
+        _sqlDbType = sqlDbType;
     }
 
+    /// <summary>
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+    /// </summary>
+    public virtual SqlDbType? SqlType
+        => _sqlDbType;
+
     /// <summary>
     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
     ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
     ///     any release. You should only use it directly in your code with extreme caution and knowing that
     ///     doing so can result in application failures when updating to a new Entity Framework Core release.
     /// </summary>
     protected override RelationalTypeMapping Clone(RelationalTypeMappingParameters parameters)
-        => new SqlServerDecimalTypeMapping(parameters);
+        => new SqlServerDecimalTypeMapping(parameters, _sqlDbType);
 
     /// <summary>
     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
@@ -65,6 +79,11 @@ protected override void ConfigureParameter(DbParameter parameter)
     {
         base.ConfigureParameter(parameter);
 
+        if (_sqlDbType != null)
+        {
+            ((SqlParameter)parameter).SqlDbType = _sqlDbType.Value;
+        }
+
         if (Size.HasValue
             && Size.Value != -1)
         {

src/EFCore.SqlServer/Storage/Internal/SqlServerTypeMappingSource.cs

@@ -88,14 +88,17 @@ private readonly SqlServerByteArrayTypeMapping _fixedLengthBinary
     private readonly SqlServerDateTimeTypeMapping _date
         = new("date", DbType.Date);
 
+    private readonly SqlServerDateTimeTypeMapping _smallDatetime
+        = new("smalldatetime", DbType.DateTime, SqlDbType.SmallDateTime);
+
     private readonly SqlServerDateTimeTypeMapping _datetime
         = new("datetime", DbType.DateTime);
 
     private readonly SqlServerDateTimeTypeMapping _datetime2
         = new("datetime2", DbType.DateTime2);
 
     private readonly SqlServerDateTimeTypeMapping _datetime2Alias
-        = new("placeholder", DbType.DateTime2, StoreTypePostfix.None);
+        = new("placeholder", DbType.DateTime2, null, StoreTypePostfix.None);
 
     private readonly DoubleTypeMapping _double
         = new SqlServerDoubleTypeMapping("float");
@@ -113,7 +116,7 @@ private readonly GuidTypeMapping _uniqueidentifier
         = new("uniqueidentifier");
 
     private readonly DecimalTypeMapping _decimal
-        = new SqlServerDecimalTypeMapping("decimal");
+        = new SqlServerDecimalTypeMapping("decimal", precision: 18, scale: 0);
 
     private readonly DecimalTypeMapping _decimalAlias
         = new SqlServerDecimalTypeMapping("placeholder", precision: 18, scale: 2, storeTypePostfix: StoreTypePostfix.None);
@@ -122,7 +125,11 @@ private readonly DecimalTypeMapping _decimal182
         = new SqlServerDecimalTypeMapping("decimal(18, 2)", precision: 18, scale: 2);
 
     private readonly DecimalTypeMapping _money
-        = new SqlServerDecimalTypeMapping("money", storeTypePostfix: StoreTypePostfix.None);
+        = new SqlServerDecimalTypeMapping("money", DbType.Currency, sqlDbType: SqlDbType.Money, storeTypePostfix: StoreTypePostfix.None);
+
+    private readonly DecimalTypeMapping _smallMoney
+        = new SqlServerDecimalTypeMapping(
+            "smallmoney", DbType.Currency, sqlDbType: SqlDbType.SmallMoney, storeTypePostfix: StoreTypePostfix.None);
 
     private readonly TimeSpanTypeMapping _time
         = new SqlServerTimeSpanTypeMapping("time");
@@ -214,9 +221,9 @@ public SqlServerTypeMappingSource(
                 { "nvarchar(max)", _variableLengthMaxUnicodeString },
                 { "real", _real },
                 { "rowversion", _rowversion },
-                { "smalldatetime", _datetime },
+                { "smalldatetime", _smallDatetime },
                 { "smallint", _short },
-                { "smallmoney", _money },
+                { "smallmoney", _smallMoney },
                 { "sql_variant", _sqlVariant },
                 { "text", _textAnsiString },
                 { "time", _time },

test/EFCore.Relational.Tests/Storage/RelationalTypeMappingTest.cs

@@ -69,6 +69,11 @@ public virtual void Create_and_clone_with_converter(Type mappingType, Type type)
             null,
             null);
 
+        AssertClone(type, mapping);
+    }
+
+    protected static RelationalTypeMapping AssertClone(Type type, RelationalTypeMapping mapping)
+    {
         var clone = mapping.Clone("<clone>", null);
 
         Assert.NotSame(mapping, clone);
@@ -97,6 +102,8 @@ public virtual void Create_and_clone_with_converter(Type mappingType, Type type)
         Assert.Same(mapping.ProviderValueComparer, clone.ProviderValueComparer);
         Assert.Same(typeof(object), clone.ClrType);
         Assert.Equal(StoreTypePostfix.PrecisionAndScale, clone.StoreTypePostfix);
+
+        return clone;
     }
 
     [ConditionalFact]
@@ -230,7 +237,7 @@ protected virtual void UnicodeConversionCloneTest(
         Assert.Equal(StoreTypePostfix.Size, clone.StoreTypePostfix);
     }
 
-    private class FakeTypeMapping : RelationalTypeMapping
+    protected class FakeTypeMapping : RelationalTypeMapping
     {
         private FakeTypeMapping(RelationalTypeMappingParameters parameters)
             : base(parameters)