- 优化 TypeHandlers 支持 DateTime 映射规则；#1634

FreeSql/FreeSqlBuilder.cs

@@ -612,9 +612,10 @@ namespace FreeSql
                 {
                     if (e.Property.PropertyType == typeHandler.Type)
                     {
-                        if (_dicTypeHandlerTypes.ContainsKey(e.Property.PropertyType) == false &&
+                        if (_dicTypeHandlerTypes.ContainsKey(e.Property.PropertyType)) return;
+                        if (e.Property.PropertyType.NullableTypeOrThis() != typeof(DateTime) &&
                             FreeSql.Internal.Utils.dicExecuteArrayRowReadClassOrTuple.ContainsKey(e.Property.PropertyType))
-                            return; //基础类型无效
+                            return; //基础类型无效，DateTime 除外
 
                         if (_dicTypeHandlerTypes.TryAdd(e.Property.PropertyType, true))
                         {

FreeSql/Internal/UtilsExpressionTree.cs

@@ -2447,6 +2447,14 @@ namespace FreeSql.Internal
                            );
                         break;
                     case "System.DateTime":
+                        if (TypeHandlers.ContainsKey(type))
+                        {
+                            foreach (var switchFunc in GetDataReaderValueBlockExpressionSwitchTypeFullName)
+                            {
+                                var switchFuncRet = switchFunc(returnTarget, valueExp, type);
+                                if (switchFuncRet != null) return switchFuncRet;
+                            }
+                        }
                         tryparseExp = Expression.Block(
                               new[] { tryparseVarExp = Expression.Variable(typeof(DateTime)) },
                                new Expression[] {

Providers/FreeSql.Provider.ClickHouse/ClickHouseAdo/ClickHouseAdo.cs

@@ -57,8 +57,18 @@ namespace FreeSql.ClickHouse
                 return string.Concat("'", param.ToString().Replace("'", "''").Replace("\\", "\\\\"), "'"); //((Enum)val).ToInt64();
             else if (decimal.TryParse(string.Concat(param), out var trydec))
                 return param;
-            else if (param is DateTime || param is DateTime?)
+
+            else if (param is DateTime)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(param);
                 return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss"), "'");
+            }
+            else if (param is DateTime?)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(param);
+                return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss"), "'");
+            }
+
             else if (param is TimeSpan || param is TimeSpan?)
                 return ((TimeSpan)param).Ticks / 10;
             else if (param is byte[])

Providers/FreeSql.Provider.Custom/CustomAdapter.cs

@@ -51,6 +51,9 @@ namespace FreeSql.Custom
         {
             if (value == null) return "NULL";
             if (value.Equals(DateTime.MinValue) == true) value = new DateTime(1970, 1, 1);
+
+            if (value is DateTime && Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(value)?.ToString();
+            if (value is DateTime? && Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler2)) return typeHandler2.Serialize(value)?.ToString();
             return string.Concat("'", ((DateTime)value).ToString("yyyy-MM-dd HH:mm:ss"), "'");
         }
         public virtual string TimeSpanRawSql(object value) => value == null ? "NULL" : ((TimeSpan)value).TotalSeconds.ToString();

Providers/FreeSql.Provider.Custom/MySql/CustomMySqlAdo/CustomMySqlAdo.cs

@@ -42,8 +42,18 @@ namespace FreeSql.Custom.MySql
                 return string.Concat("'", param.ToString().Replace("'", "''").Replace("\\", "\\\\").Replace(", ", ","), "'"); //((Enum)val).ToInt64();
             else if (decimal.TryParse(string.Concat(param), out var trydec))
                 return param;
-            else if (param is DateTime || param is DateTime?)
+
+            else if (param is DateTime)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(param);
                 return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.fff"), "'");
+            }
+            else if (param is DateTime?)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(param);
+                return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.fff"), "'");
+            }
+
             else if (param is TimeSpan || param is TimeSpan?)
                 return ((TimeSpan)param).Ticks / 10;
             else if (param is byte[])

Providers/FreeSql.Provider.Custom/Oracle/CustomOracleAdo/CustomOracleAdo.cs

@@ -56,8 +56,18 @@ namespace FreeSql.Custom.Oracle
                 return ((Enum)param).ToInt64();
             else if (decimal.TryParse(string.Concat(param), out var trydec))
                 return param;
-            else if (param is DateTime || param is DateTime?)
+
+            else if (param is DateTime)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(param);
                 return string.Concat("to_timestamp('", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "','YYYY-MM-DD HH24:MI:SS.FF6')");
+            }
+            else if (param is DateTime?)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(param);
+                return string.Concat("to_timestamp('", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "','YYYY-MM-DD HH24:MI:SS.FF6')");
+            }
+
             else if (param is TimeSpan || param is TimeSpan?)
                 return $"numtodsinterval({((TimeSpan)param).Ticks * 1.0 / 10000000},'second')";
             else if (param is IEnumerable)

Providers/FreeSql.Provider.Custom/OracleAdapter.cs

@@ -51,6 +51,9 @@ namespace FreeSql.Custom
         {
             if (value == null) return "NULL";
             if (value.Equals(DateTime.MinValue) == true) value = new DateTime(1970, 1, 1);
+
+            if (value is DateTime && Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(value)?.ToString();
+            if (value is DateTime? && Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler2)) return typeHandler2.Serialize(value)?.ToString();
             return string.Concat("'", ((DateTime)value).ToString("yyyy-MM-dd HH:mm:ss"), "'");
         }
         public virtual string TimeSpanRawSql(object value) => value == null ? "NULL" : ((TimeSpan)value).TotalSeconds.ToString();

Providers/FreeSql.Provider.Custom/PostgreSQL/CustomPostgreSQLAdo/CustomPostgreSQLAdo.cs

@@ -44,8 +44,18 @@ namespace FreeSql.Custom.PostgreSQL
                 return ((Enum)param).ToInt64();
             else if (decimal.TryParse(string.Concat(param), out var trydec))
                 return param;
-            else if (param is DateTime || param is DateTime?)
+
+            else if (param is DateTime)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(param);
                 return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "'");
+            }
+            else if (param is DateTime?)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(param);
+                return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "'");
+            }
+
             else if (param is TimeSpan || param is TimeSpan?)
                 return ((TimeSpan)param).Ticks / 10;
             else if (param is byte[])

Providers/FreeSql.Provider.Custom/SqlServer/CustomSqlServerAdo/CustomSqlServerAdo.cs

@@ -49,11 +49,18 @@ namespace FreeSql.Custom.SqlServer
                 return ((Enum)param).ToInt64();
             else if (decimal.TryParse(string.Concat(param), out var trydec))
                 return param;
-            else if (param is DateTime || param is DateTime?)
+
+            else if (param is DateTime)
             {
-                if (param.Equals(DateTime.MinValue) == true) param = new DateTime(1970, 1, 1);
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(param);
                 return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.fff"), "'");
             }
+            else if (param is DateTime?)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(param);
+                return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.fff"), "'");
+            }
+
             else if (param is DateTimeOffset || param is DateTimeOffset?)
             {
                 if (param.Equals(DateTimeOffset.MinValue) == true) param = new DateTimeOffset(new DateTime(1970, 1, 1), TimeSpan.Zero);

Providers/FreeSql.Provider.Dameng/DamengAdo/DamengAdo.cs

@@ -58,8 +58,18 @@ namespace FreeSql.Dameng
                 return ((Enum)param).ToInt64();
             else if (decimal.TryParse(string.Concat(param), out var trydec))
                 return param;
-            else if (param is DateTime || param is DateTime?)
+
+            else if (param is DateTime)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(param);
                 return string.Concat("to_timestamp('", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "','YYYY-MM-DD HH24:MI:SS.FF6')");
+            }
+            else if (param is DateTime?)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(param);
+                return string.Concat("to_timestamp('", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "','YYYY-MM-DD HH24:MI:SS.FF6')");
+            }
+
             else if (param is TimeSpan || param is TimeSpan?)
                 return $"numtodsinterval({((TimeSpan)param).Ticks * 1.0 / 10000000},'second')";
             else if (param is IEnumerable)

Providers/FreeSql.Provider.Firebird/FirebirdAdo/FirebirdAdo.cs

@@ -79,8 +79,18 @@ namespace FreeSql.Firebird
                 return ((Enum)param).ToInt64();
             else if (decimal.TryParse(string.Concat(param), out var trydec))
                 return param;
-            else if (param is DateTime || param is DateTime?)
+
+            else if (param is DateTime)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(param);
                 return string.Concat("timestamp '", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.fff"), "'");
+            }
+            else if (param is DateTime?)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(param);
+                return string.Concat("timestamp '", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.fff"), "'");
+            }
+
             else if (param is TimeSpan || param is TimeSpan?)
                 return ((TimeSpan)param).Ticks / 10;
             else if (param is byte[])

Providers/FreeSql.Provider.GBase/GBaseAdo/GBaseAdo.cs

@@ -57,12 +57,22 @@ namespace FreeSql.GBase
                 return ((Enum)param).ToInt64();
             else if (decimal.TryParse(string.Concat(param), out var trydec))
                 return param;
-            else if (param is DateTime || param is DateTime?)
+
+            else if (param is DateTime)
             {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(param);
                 if (mapColumn?.DbPrecision > 0)
                     return string.Concat("'", ((DateTime)param).ToString($"yyyy-MM-dd HH:mm:ss.{"f".PadRight(mapColumn.DbPrecision, 'f')}"), "'");
                 return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss"), "'");
             }
+            else if (param is DateTime?)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(param);
+                if (mapColumn?.DbPrecision > 0)
+                    return string.Concat("'", ((DateTime)param).ToString($"yyyy-MM-dd HH:mm:ss.{"f".PadRight(mapColumn.DbPrecision, 'f')}"), "'");
+                return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss"), "'");
+            }
+
             else if (param is TimeSpan || param is TimeSpan?)
             {
                 var ts = (TimeSpan)param;

Providers/FreeSql.Provider.GBase/GBaseUtils.cs

@@ -100,8 +100,16 @@ namespace FreeSql.GBase
                 var ts = (TimeSpan)value;
                 return $"interval({ts.Days} {ts.Hours}:{ts.Minutes}:{ts.Seconds}.{ts.Milliseconds}) day(9) to fraction";
             }
-            if (type == typeof(DateTime) || type == typeof(DateTime?))
+            if (type == typeof(DateTime))
             {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(value)?.ToString();
+                if (col?.DbPrecision > 0)
+                    return string.Concat("'", ((DateTime)value).ToString($"yyyy-MM-dd HH:mm:ss.{"f".PadRight(col.DbPrecision, 'f')}"), "'");
+                return string.Concat("'", ((DateTime)value).ToString("yyyy-MM-dd HH:mm:ss"), "'");
+            }
+            if (type == typeof(DateTime?))
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(value)?.ToString();
                 if (col?.DbPrecision > 0)
                     return string.Concat("'", ((DateTime)value).ToString($"yyyy-MM-dd HH:mm:ss.{"f".PadRight(col.DbPrecision, 'f')}"), "'");
                 return string.Concat("'", ((DateTime)value).ToString("yyyy-MM-dd HH:mm:ss"), "'");

Providers/FreeSql.Provider.KingbaseES/KingbaseESAdo/KingbaseESAdo.cs

@@ -56,8 +56,18 @@ namespace FreeSql.KingbaseES
                 return ((Enum)param).ToInt64();
             else if (decimal.TryParse(string.Concat(param), out var trydec))
                 return param;
-            else if (param is DateTime || param is DateTime?)
+
+            else if (param is DateTime)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(param);
                 return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "'");
+            }
+            else if (param is DateTime?)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(param);
+                return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "'");
+            }
+
             else if (param is TimeSpan || param is TimeSpan?)
                 return ((TimeSpan)param).Ticks / 10;
             else if (param is byte[])

Providers/FreeSql.Provider.MsAccess/MsAccessAdo/MsAccessAdo.cs

@@ -57,11 +57,20 @@ namespace FreeSql.MsAccess
                 return ((Enum)param).ToInt64();
             else if (decimal.TryParse(string.Concat(param), out var trydec))
                 return param;
-            else if (param is DateTime || param is DateTime?)
+
+            else if (param is DateTime)
             {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(param);
                 if (param.Equals(DateTime.MinValue) == true) param = new DateTime(1970, 1, 1);
                 return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss"), "'");
             }
+            else if (param is DateTime?)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(param);
+                if (param.Equals(DateTime.MinValue) == true) param = new DateTime(1970, 1, 1);
+                return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss"), "'");
+            }
+
             else if (param is TimeSpan || param is TimeSpan?)
                 return ((TimeSpan)param).TotalSeconds;
             else if (param is byte[])

Providers/FreeSql.Provider.MySql/MySqlAdo/MySqlAdo.cs

@@ -61,8 +61,18 @@ namespace FreeSql.MySql
                 return string.Concat("'", param.ToString().Replace("'", "''").Replace("\\", "\\\\").Replace(", ", ","), "'"); //((Enum)val).ToInt64();
             else if (decimal.TryParse(string.Concat(param), out var trydec))
                 return param;
-            else if (param is DateTime || param is DateTime?)
+
+            else if (param is DateTime)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(param);
                 return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.fff"), "'");
+            }
+            else if (param is DateTime?)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(param);
+                return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.fff"), "'");
+            }
+
             else if (param is TimeSpan || param is TimeSpan?)
                 return ((TimeSpan)param).Ticks / 10;
             else if (param is byte[])

Providers/FreeSql.Provider.Odbc/Dameng/OdbcDamengAdo/OdbcDamengAdo.cs

@@ -59,8 +59,18 @@ namespace FreeSql.Odbc.Dameng
                 return ((Enum)param).ToInt64();
             else if (decimal.TryParse(string.Concat(param), out var trydec))
                 return param;
-            else if (param is DateTime || param is DateTime?)
+
+            else if (param is DateTime)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(param);
                 return string.Concat("to_timestamp('", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "','YYYY-MM-DD HH24:MI:SS.FF6')");
+            }
+            else if (param is DateTime?)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(param);
+                return string.Concat("to_timestamp('", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "','YYYY-MM-DD HH24:MI:SS.FF6')");
+            }
+
             else if (param is TimeSpan || param is TimeSpan?)
                 return $"numtodsinterval({((TimeSpan)param).Ticks * 1.0 / 10000000},'second')";
             else if (param is IEnumerable)

Providers/FreeSql.Provider.Odbc/Default/OdbcAdapter.cs

@@ -51,6 +51,9 @@ namespace FreeSql.Odbc.Default
         {
             if (value == null) return "NULL";
             if (value.Equals(DateTime.MinValue) == true) value = new DateTime(1970, 1, 1);
+
+            if (value is DateTime && Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(value)?.ToString();
+            if (value is DateTime? && Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler2)) return typeHandler2.Serialize(value)?.ToString();
             return string.Concat("'", ((DateTime)value).ToString("yyyy-MM-dd HH:mm:ss"), "'");
         }
         public virtual string TimeSpanRawSql(object value) => value == null ? "NULL" : ((TimeSpan)value).TotalSeconds.ToString();

Providers/FreeSql.Provider.Odbc/KingbaseES/OdbcKingbaseESAdo/OdbcKingbaseESAdo.cs

@@ -59,8 +59,18 @@ namespace FreeSql.Odbc.KingbaseES
                 return ((Enum)param).ToInt64();
             else if (decimal.TryParse(string.Concat(param), out var trydec))
                 return param;
-            else if (param is DateTime || param is DateTime?)
+
+            else if (param is DateTime)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(param);
                 return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "'");
+            }
+            else if (param is DateTime?)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(param);
+                return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "'");
+            }
+
             else if (param is TimeSpan || param is TimeSpan?)
                 return ((TimeSpan)param).Ticks / 10;
             else if (param is byte[])

Providers/FreeSql.Provider.Odbc/MySql/OdbcMySqlAdo/OdbcMySqlAdo.cs

@@ -59,8 +59,18 @@ namespace FreeSql.Odbc.MySql
                 return string.Concat("'", param.ToString().Replace("'", "''").Replace("\\", "\\\\").Replace(", ", ","), "'"); //((Enum)val).ToInt64();
             else if (decimal.TryParse(string.Concat(param), out var trydec))
                 return param;
-            else if (param is DateTime || param is DateTime?)
+
+            else if (param is DateTime)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(param);
                 return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.fff"), "'");
+            }
+            else if (param is DateTime?)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(param);
+                return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.fff"), "'");
+            }
+
             else if (param is TimeSpan || param is TimeSpan?)
                 return ((TimeSpan)param).Ticks / 10;
             else if (param is byte[])

Providers/FreeSql.Provider.Odbc/Oracle/OdbcOracleAdo/OdbcOracleAdo.cs

@@ -60,8 +60,18 @@ namespace FreeSql.Odbc.Oracle
                 return ((Enum)param).ToInt64();
             else if (decimal.TryParse(string.Concat(param), out var trydec))
                 return param;
-            else if (param is DateTime || param is DateTime?)
+
+            else if (param is DateTime)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(param);
                 return string.Concat("to_timestamp('", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "','YYYY-MM-DD HH24:MI:SS.FF6')");
+            }
+            else if (param is DateTime?)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(param);
+                return string.Concat("to_timestamp('", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "','YYYY-MM-DD HH24:MI:SS.FF6')");
+            }
+
             else if (param is TimeSpan || param is TimeSpan?)
                 return $"numtodsinterval({((TimeSpan)param).Ticks * 1.0 / 10000000},'second')";
             else if (param is IEnumerable)

Providers/FreeSql.Provider.Odbc/PostgreSQL/OdbcPostgreSQLAdo/OdbcPostgreSQLAdo.cs

@@ -60,8 +60,18 @@ namespace FreeSql.Odbc.PostgreSQL
                 return ((Enum)param).ToInt64();
             else if (decimal.TryParse(string.Concat(param), out var trydec))
                 return param;
-            else if (param is DateTime || param is DateTime?)
+
+            else if (param is DateTime)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(param);
                 return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "'");
+            }
+            else if (param is DateTime?)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(param);
+                return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "'");
+            }
+
             else if (param is TimeSpan || param is TimeSpan?)
                 return ((TimeSpan)param).Ticks / 10;
             else if (param is byte[])

Providers/FreeSql.Provider.Odbc/SqlServer/OdbcSqlServerAdo/OdbcSqlServerAdo.cs

@@ -64,11 +64,20 @@ namespace FreeSql.Odbc.SqlServer
                 return ((Enum)param).ToInt64();
             else if (decimal.TryParse(string.Concat(param), out var trydec))
                 return param;
-            else if (param is DateTime || param is DateTime?)
+
+            else if (param is DateTime)
             {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(param);
                 if (param.Equals(DateTime.MinValue) == true) param = new DateTime(1970, 1, 1);
                 return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.fff"), "'");
             }
+            else if (param is DateTime?)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(param);
+                if (param.Equals(DateTime.MinValue) == true) param = new DateTime(1970, 1, 1);
+                return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.fff"), "'");
+            }
+
             else if (param is DateTimeOffset || param is DateTimeOffset?)
             {
                 if (param.Equals(DateTimeOffset.MinValue) == true) param = new DateTimeOffset(new DateTime(1970, 1, 1), TimeSpan.Zero);

Providers/FreeSql.Provider.Oracle/OracleAdo/OracleAdo.cs

@@ -57,8 +57,18 @@ namespace FreeSql.Oracle
                 return ((Enum)param).ToInt64();
             else if (decimal.TryParse(string.Concat(param), out var trydec))
                 return param;
-            else if (param is DateTime || param is DateTime?)
+
+            else if (param is DateTime)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(param);
                 return string.Concat("to_timestamp('", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "','YYYY-MM-DD HH24:MI:SS.FF6')");
+            }
+            else if (param is DateTime?)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(param);
+                return string.Concat("to_timestamp('", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "','YYYY-MM-DD HH24:MI:SS.FF6')");
+            }
+
             else if (param is TimeSpan || param is TimeSpan?)
                 return $"numtodsinterval({((TimeSpan)param).Ticks * 1.0 / 10000000},'second')";
             else if (param is IEnumerable)

Providers/FreeSql.Provider.PostgreSQL/PostgreSQLAdo/PostgreSQLAdo.cs

@@ -61,8 +61,18 @@ namespace FreeSql.PostgreSQL
                 return ((Enum)param).ToInt64();
             else if (decimal.TryParse(string.Concat(param), out var trydec))
                 return param;
-            else if (param is DateTime || param is DateTime?)
+
+            else if (param is DateTime)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(param);
                 return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "'");
+            }
+            else if (param is DateTime?)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(param);
+                return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "'");
+            }
+
             else if (param is TimeSpan || param is TimeSpan?)
                 return ((TimeSpan)param).Ticks / 10;
             else if (param is byte[])

Providers/FreeSql.Provider.QuestDb/QuestDbAdo/QuestDbAdo.cs

@@ -63,8 +63,18 @@ namespace FreeSql.QuestDb
                 return ((Enum)param).ToInt64();
             else if (decimal.TryParse(string.Concat(param), out var trydec))
                 return param;
-            else if (param is DateTime || param is DateTime?)
+
+            else if (param is DateTime)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(param);
                 return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "'");
+            }
+            else if (param is DateTime?)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(param);
+                return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "'");
+            }
+
             else if (param is TimeSpan || param is TimeSpan?)
                 return (long)((TimeSpan)param).TotalSeconds;
             else if (param is byte[])

Providers/FreeSql.Provider.ShenTong/ShenTongAdo/ShenTongAdo.cs

@@ -57,8 +57,18 @@ namespace FreeSql.ShenTong
                 return ((Enum)param).ToInt64();
             else if (decimal.TryParse(string.Concat(param), out var trydec))
                 return param;
-            else if (param is DateTime || param is DateTime?)
+
+            else if (param is DateTime)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(param);
                 return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "'");
+            }
+            else if (param is DateTime?)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(param);
+                return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "'");
+            }
+
             else if (param is TimeSpan || param is TimeSpan?)
                 return ((TimeSpan)param).TotalSeconds;
             else if (param is byte[])

Providers/FreeSql.Provider.SqlServer/SqlServerAdo/SqlServerAdo.cs

@@ -68,11 +68,20 @@ namespace FreeSql.SqlServer
                 return ((Enum)param).ToInt64();
             else if (decimal.TryParse(string.Concat(param), out var trydec))
                 return param;
-            else if (param is DateTime || param is DateTime?)
+
+            else if (param is DateTime)
             {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(param);
                 if (param.Equals(DateTime.MinValue) == true) param = new DateTime(1970, 1, 1);
                 return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.fff"), "'");
             }
+            else if (param is DateTime?)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(param);
+                if (param.Equals(DateTime.MinValue) == true) param = new DateTime(1970, 1, 1);
+                return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.fff"), "'");
+            }
+
             else if (param is DateTimeOffset || param is DateTimeOffset?)
             {
                 if (param.Equals(DateTimeOffset.MinValue) == true) param = new DateTimeOffset(new DateTime(1970, 1, 1), TimeSpan.Zero);

Providers/FreeSql.Provider.Sqlite/SqliteAdo/SqliteAdo.cs

@@ -62,8 +62,18 @@ namespace FreeSql.Sqlite
                 return ((Enum)param).ToInt64();
             else if (decimal.TryParse(string.Concat(param), out var trydec))
                 return param;
-            else if (param is DateTime || param is DateTime?)
+
+            else if (param is DateTime)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(param);
                 return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss"), "'");
+            }
+            else if (param is DateTime?)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(param);
+                return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss"), "'");
+            }
+
             else if (param is TimeSpan || param is TimeSpan?)
                 return ((TimeSpan)param).TotalSeconds;
             else if (param is byte[])

Providers/FreeSql.Provider.Xugu/XuguAdo/XuguAdo.cs

@@ -59,8 +59,18 @@ namespace FreeSql.Xugu
                 return ((Enum)param).ToInt64();
             else if (decimal.TryParse(string.Concat(param), out var trydec))
                 return param;
-            else if (param is DateTime || param is DateTime?)
+
+            else if (param is DateTime)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime), out var typeHandler)) return typeHandler.Serialize(param);
                 return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "'");
+            }
+            else if (param is DateTime?)
+            {
+                if (Utils.TypeHandlers.TryGetValue(typeof(DateTime?), out var typeHandler)) return typeHandler.Serialize(param);
+                return string.Concat("'", ((DateTime)param).ToString("yyyy-MM-dd HH:mm:ss.ffffff"), "'");
+            }
+
             else if (param is TimeSpan || param is TimeSpan?)
                 return ((TimeSpan)param).Ticks / 10;
             else if (param is byte[])