From f1fedd9578d306e427ed41264d8b9f3e8098b354 Mon Sep 17 00:00:00 2001 From: sunkaixuan <610262374@qq.com> Date: Thu, 13 Feb 2025 14:09:23 +0800 Subject: [PATCH] Synchronization code --- .../Abstract/AdoProvider/AdoProvider.cs | 12 ++++-- .../CodeFirstProvider/CodeFirstProvider.cs | 2 +- .../Abstract/DbBindProvider/DbBindProvider.cs | 43 +++++++++++++++++++ .../EntityMaintenance/EntityMaintenance.cs | 6 +++ .../InsertableProvider/InsertableHelper.cs | 1 + .../QueryableProvider/QueryableExecuteSql.cs | 7 ++- .../QueryableProvider/QueryableHelper.cs | 19 +++++++- .../QueryableProvider/QueryableProvider.cs | 24 ++++++++++- .../SqlBuilderProvider/InsertBuilder.cs | 37 ++++++++++------ .../SqlBuilderProvider/QueryBuilder.cs | 3 +- .../SqlBuilderProvider/SqlBuilderProvider.cs | 4 +- .../SqlBuilderProvider/UpdateBuilder.cs | 20 +++++++-- .../UpdateProvider/UpdateableHelper.cs | 4 ++ .../UpdateProvider/UpdateableProvider.cs | 10 ++++- .../DbMethods/DefaultDbMethod.cs | 12 +++++- .../ExpressionsToSql/DbMethods/IDbMethods.cs | 2 + .../ExpressionsToSql/DbMethods/SqlFunc.cs | 6 +++ .../ResolveItems/MemberExpressionResolve.cs | 5 +++ .../MethodCallExpressionResolve_Helper.cs | 4 ++ .../Infrastructure/InstanceFactory.cs | 4 ++ Src/Asp.Net/SqlSugar/Interface/IQueryable.cs | 1 + 21 files changed, 198 insertions(+), 28 deletions(-) diff --git a/Src/Asp.Net/SqlSugar/Abstract/AdoProvider/AdoProvider.cs b/Src/Asp.Net/SqlSugar/Abstract/AdoProvider/AdoProvider.cs index 196da4339..e90eb2183 100644 --- a/Src/Asp.Net/SqlSugar/Abstract/AdoProvider/AdoProvider.cs +++ b/Src/Asp.Net/SqlSugar/Abstract/AdoProvider/AdoProvider.cs @@ -31,6 +31,7 @@ namespace SqlSugar #endregion #region Properties + internal bool IsOpenAsync { get; set; } protected List OutputParameters { get; set; } public virtual string SqlParameterKeyWord { get { return "@"; } } public IDbTransaction Transaction { get; set; } @@ -626,7 +627,7 @@ namespace SqlSugar if (this.ProcessingEventStartingSQL != null) ExecuteProcessingSQL(ref sql,ref parameters); ExecuteBefore(sql, parameters); - var sqlCommand = GetCommand(sql, parameters); + var sqlCommand =IsOpenAsync? await GetCommandAsync(sql, parameters) : GetCommand(sql, parameters); int count; if (this.CancellationToken == null) count=await sqlCommand.ExecuteNonQueryAsync(); @@ -668,7 +669,7 @@ namespace SqlSugar if (this.ProcessingEventStartingSQL != null) ExecuteProcessingSQL(ref sql,ref parameters); ExecuteBefore(sql, parameters); - var sqlCommand = GetCommand(sql, parameters); + var sqlCommand = IsOpenAsync ? await GetCommandAsync(sql, parameters) : GetCommand(sql, parameters); DbDataReader sqlDataReader; if(this.CancellationToken==null) sqlDataReader=await sqlCommand.ExecuteReaderAsync(this.IsAutoClose() ? CommandBehavior.CloseConnection : CommandBehavior.Default); @@ -707,7 +708,7 @@ namespace SqlSugar if (this.ProcessingEventStartingSQL != null) ExecuteProcessingSQL(ref sql,ref parameters); ExecuteBefore(sql, parameters); - var sqlCommand = GetCommand(sql, parameters); + var sqlCommand = IsOpenAsync ? await GetCommandAsync(sql, parameters) : GetCommand(sql, parameters); object scalar; if(CancellationToken==null) scalar=await sqlCommand.ExecuteScalarAsync(); @@ -1461,6 +1462,11 @@ namespace SqlSugar #endregion #region Helper + public virtual async Task GetCommandAsync(string sql, SugarParameter[] parameters) + { + await Task.FromResult(0); + throw new NotImplementedException(); + } public async Task CloseAsync() { if (this.Transaction != null) diff --git a/Src/Asp.Net/SqlSugar/Abstract/CodeFirstProvider/CodeFirstProvider.cs b/Src/Asp.Net/SqlSugar/Abstract/CodeFirstProvider/CodeFirstProvider.cs index 93959676e..e58823d50 100644 --- a/Src/Asp.Net/SqlSugar/Abstract/CodeFirstProvider/CodeFirstProvider.cs +++ b/Src/Asp.Net/SqlSugar/Abstract/CodeFirstProvider/CodeFirstProvider.cs @@ -200,7 +200,7 @@ namespace SqlSugar var tempTableName = "TempDiff" + DateTime.Now.ToString("yyMMssHHmmssfff"); var oldTableName = this.Context.EntityMaintenance.GetEntityInfo(type).DbTableName; var db = new SqlSugarProvider(UtilMethods.CopyConfig(this.Context.CurrentConnectionConfig)); - UtilMethods.IsNullReturnNew(db.CurrentConnectionConfig.ConfigureExternalServices); + db.CurrentConnectionConfig.ConfigureExternalServices=UtilMethods.IsNullReturnNew(db.CurrentConnectionConfig.ConfigureExternalServices); db.CurrentConnectionConfig.ConfigureExternalServices.EntityNameService += (x, p) => { p.IsDisabledUpdateAll = true;//Disabled update diff --git a/Src/Asp.Net/SqlSugar/Abstract/DbBindProvider/DbBindProvider.cs b/Src/Asp.Net/SqlSugar/Abstract/DbBindProvider/DbBindProvider.cs index 4a349e9f1..a97d5c0ca 100644 --- a/Src/Asp.Net/SqlSugar/Abstract/DbBindProvider/DbBindProvider.cs +++ b/Src/Asp.Net/SqlSugar/Abstract/DbBindProvider/DbBindProvider.cs @@ -1,4 +1,5 @@ using System; +using System.Collections; using System.Collections.Generic; using System.Data; using System.Linq; @@ -214,12 +215,18 @@ namespace SqlSugar { return GetArrayList(type, dataReader); } + else if (typeof(T)!=type&&typeof(T).IsInterface) + { + //这里是为了解决返回类型是接口的问题 + return GetEntityListByType(type, Context, dataReader); + } else { return GetEntityList(Context, dataReader); } } } + public virtual async Task> DataReaderToListAsync(Type type, IDataReader dataReader) { using (dataReader) @@ -236,6 +243,11 @@ namespace SqlSugar { return await GetArrayListAsync(type, dataReader); } + else if (typeof(T) != type && typeof(T).IsInterface) + { + //这里是为了解决返回类型是接口的问题 + return await GetEntityListByTypeAsync(type, Context, dataReader); + } else { return await GetEntityListAsync(Context, dataReader); @@ -280,6 +292,37 @@ namespace SqlSugar return GetEntityListAsync(Context, dataReader); } } + public virtual List GetEntityListByType(Type entityType, SqlSugarProvider context, IDataReader dataReader) + { + var method = typeof(DbBindProvider).GetMethod("GetEntityList", BindingFlags.Instance | BindingFlags.NonPublic); + var genericMethod = method.MakeGenericMethod(entityType); + var objectValue= genericMethod.Invoke(this, new object[] { context, dataReader }); + List result = new List(); + foreach (var item in objectValue as IEnumerable) + { + result.Add((T)item); + } + return result; + } + public virtual async Task> GetEntityListByTypeAsync(Type entityType, SqlSugarProvider context, IDataReader dataReader) + { + var method = typeof(DbBindProvider).GetMethod("GetEntityListAsync", BindingFlags.Instance | BindingFlags.NonPublic); + var genericMethod = method.MakeGenericMethod(entityType); + Task task = (Task)genericMethod.Invoke(this, new object[] { context, dataReader }); + return await GetTask(task); + } + private static async Task> GetTask(Task task) + { + await task.ConfigureAwait(false); // 等待任务完成 + var resultProperty = task.GetType().GetProperty("Result"); + var value = resultProperty.GetValue(task); + List result = new List(); + foreach (var item in value as IEnumerable) + { + result.Add((T)item); + } + return (List)result; + } #endregion #region Throw rule diff --git a/Src/Asp.Net/SqlSugar/Abstract/EntityMaintenance/EntityMaintenance.cs b/Src/Asp.Net/SqlSugar/Abstract/EntityMaintenance/EntityMaintenance.cs index e04255963..90916e5c4 100644 --- a/Src/Asp.Net/SqlSugar/Abstract/EntityMaintenance/EntityMaintenance.cs +++ b/Src/Asp.Net/SqlSugar/Abstract/EntityMaintenance/EntityMaintenance.cs @@ -422,7 +422,13 @@ namespace SqlSugar if (!column.EntityName.ObjToString().StartsWith("<>f__AnonymousType") &&column.PropertyInfo?.ReflectedType!=typeof(DbTableInfo)) { + var isOldOwnsOne = column.IsOwnsOne; this.Context.CurrentConnectionConfig.ConfigureExternalServices.EntityService(property, column); + if (column.IsOwnsOne == true && isOldOwnsOne == false) + { + SetValueObjectColumns(result, property, column); + continue; + } } } if (column.PropertyInfo.DeclaringType != null diff --git a/Src/Asp.Net/SqlSugar/Abstract/InsertableProvider/InsertableHelper.cs b/Src/Asp.Net/SqlSugar/Abstract/InsertableProvider/InsertableHelper.cs index 909a54440..0b5ee5403 100644 --- a/Src/Asp.Net/SqlSugar/Abstract/InsertableProvider/InsertableHelper.cs +++ b/Src/Asp.Net/SqlSugar/Abstract/InsertableProvider/InsertableHelper.cs @@ -741,6 +741,7 @@ namespace SqlSugar foreach (var item in this.InsertObjs) { var insertable = this.Context.Insertable(item) + .AS(this.InsertBuilder.AsName) .InsertColumns(this.InsertBuilder.DbColumnInfoList.Select(it => it.DbColumnName).Distinct().ToArray()); if (pkInfo.UnderType == UtilConstants.IntType) { diff --git a/Src/Asp.Net/SqlSugar/Abstract/QueryableProvider/QueryableExecuteSql.cs b/Src/Asp.Net/SqlSugar/Abstract/QueryableProvider/QueryableExecuteSql.cs index 56510ddc0..2cfab50c7 100644 --- a/Src/Asp.Net/SqlSugar/Abstract/QueryableProvider/QueryableExecuteSql.cs +++ b/Src/Asp.Net/SqlSugar/Abstract/QueryableProvider/QueryableExecuteSql.cs @@ -10,7 +10,7 @@ using System.Reflection; using System.Dynamic; using System.Threading.Tasks; using Newtonsoft.Json.Serialization; - + namespace SqlSugar { @@ -853,6 +853,11 @@ namespace SqlSugar } public virtual string ToSqlString() { + if (this.EntityInfo?.Type?.IsInterface==true) + { + this.QueryBuilder.SelectValue = " * "; + this.AsType(this.EntityInfo.Type); + } var sqlObj = this.Clone().ToSql(); var result = sqlObj.Key; if (result == null) return null; diff --git a/Src/Asp.Net/SqlSugar/Abstract/QueryableProvider/QueryableHelper.cs b/Src/Asp.Net/SqlSugar/Abstract/QueryableProvider/QueryableHelper.cs index 05dcdab7e..7a169d9fc 100644 --- a/Src/Asp.Net/SqlSugar/Abstract/QueryableProvider/QueryableHelper.cs +++ b/Src/Asp.Net/SqlSugar/Abstract/QueryableProvider/QueryableHelper.cs @@ -1889,7 +1889,14 @@ namespace SqlSugar SugarParameter[] parameters = sqlObj.Value.ToArray(); var dataReader = this.Db.GetDataReader(sqlString, parameters); this.Db.GetDataBefore(sqlString, parameters); - result = GetData(isComplexModel, entityType, dataReader); + if (entityType.IsInterface) + { + result = GetData(isComplexModel, this.QueryBuilder.AsType, dataReader); + } + else + { + result = GetData(isComplexModel, entityType, dataReader); + } this.Db.GetDataAfter(sqlString, parameters); RestChangeMasterQuery(isChangeQueryableMasterSlave); RestChangeSlaveQuery(isChangeQueryableSlave); @@ -1906,7 +1913,14 @@ namespace SqlSugar SugarParameter[] parameters = sqlObj.Value.ToArray(); var dataReader = await this.Db.GetDataReaderAsync(sqlString, parameters); this.Db.GetDataBefore(sqlString, parameters); - result = await GetDataAsync(isComplexModel, entityType, dataReader); + if (entityType.IsInterface) + { + result =await GetDataAsync(isComplexModel, this.QueryBuilder.AsType, dataReader); + } + else + { + result = await GetDataAsync(isComplexModel, entityType, dataReader); + } this.Db.GetDataAfter(sqlString, parameters); RestChangeMasterQuery(isChangeQueryableMasterSlave); RestChangeSlaveQuery(isChangeQueryableSlave); @@ -2110,6 +2124,7 @@ namespace SqlSugar asyncQueryableBuilder.JoinExpression = this.QueryBuilder.JoinExpression; asyncQueryableBuilder.WhereIndex = this.QueryBuilder.WhereIndex; asyncQueryableBuilder.HavingInfos = this.QueryBuilder.HavingInfos; + asyncQueryableBuilder.AsType = this.QueryBuilder.AsType; asyncQueryableBuilder.LambdaExpressions.ParameterIndex = this.QueryBuilder.LambdaExpressions.ParameterIndex; asyncQueryableBuilder.IgnoreColumns = this.Context.Utilities.TranslateCopy(this.QueryBuilder.IgnoreColumns); asyncQueryableBuilder.AsTables = this.Context.Utilities.TranslateCopy(this.QueryBuilder.AsTables); diff --git a/Src/Asp.Net/SqlSugar/Abstract/QueryableProvider/QueryableProvider.cs b/Src/Asp.Net/SqlSugar/Abstract/QueryableProvider/QueryableProvider.cs index fc261f885..2d2c3abd3 100644 --- a/Src/Asp.Net/SqlSugar/Abstract/QueryableProvider/QueryableProvider.cs +++ b/Src/Asp.Net/SqlSugar/Abstract/QueryableProvider/QueryableProvider.cs @@ -329,7 +329,7 @@ namespace SqlSugar } public ISugarQueryable Clone() { - var queryable = this.Context.Queryable().Select().WithCacheIF(IsCache, CacheTime); + var queryable = this.Context.Queryable().AsType(this.QueryBuilder.AsType).Select().WithCacheIF(IsCache, CacheTime); CopyQueryBuilder(queryable.QueryBuilder); ((QueryableProvider)queryable).CacheKey = this.CacheKey; ((QueryableProvider)queryable).MapperAction = this.MapperAction; @@ -359,8 +359,18 @@ namespace SqlSugar this.QueryBuilder.IsCrossQueryWithAttr = true; return this.AS(asName); } + public ISugarQueryable Cast() + { + var selectValue = this.Clone().QueryBuilder.GetSelectValue; + return this.Select().Select(selectValue); + } public ISugarQueryable AsType(Type tableNameType) { + if (tableNameType == null) + { + return this; + } + this.QueryBuilder.AsType = tableNameType; return AS(this.Context.EntityMaintenance.GetEntityInfo(tableNameType).DbTableName); } public virtual ISugarQueryable With(string withString) @@ -1495,6 +1505,11 @@ namespace SqlSugar } else if (this.QueryBuilder.EntityType == UtilConstants.ObjType || (this.QueryBuilder.AsTables != null && this.QueryBuilder.AsTables.Count == 1)||this.QueryBuilder.EntityName!=this.QueryBuilder.EntityType.Name) { + if (typeof(TResult).IsInterface&&this.QueryBuilder.AsType==null) + { + Check.ExceptionEasy("Select< interface > requires a full example of AsType(type) db.Queryable().AsType(type).Select().ToList()" + , "Select<接口>需要AsType(type)完整示例db.Queryable().AsType(type).Select().ToList()"); + } if (this.QueryBuilder.SelectValue.HasValue()&& this.QueryBuilder.SelectValue.ObjToString().Contains("AS")) { return this.Select(this.QueryBuilder.SelectValue+""); @@ -1520,6 +1535,13 @@ namespace SqlSugar } else { + if (typeof(TResult).IsInterface&& typeof(TResult).IsAssignableFrom(this.EntityInfo.Type)) + { + if (!this.QueryBuilder.AsTables.Any()) + { + this.AsType(this.EntityInfo.Type); + } + } var selects = this.QueryBuilder.GetSelectValueByString(); if (selects.ObjToString().ToLower().IsContainsIn(".","("," as ")) { diff --git a/Src/Asp.Net/SqlSugar/Abstract/SqlBuilderProvider/InsertBuilder.cs b/Src/Asp.Net/SqlSugar/Abstract/SqlBuilderProvider/InsertBuilder.cs index 5f0eed6c8..cad17a11e 100644 --- a/Src/Asp.Net/SqlSugar/Abstract/SqlBuilderProvider/InsertBuilder.cs +++ b/Src/Asp.Net/SqlSugar/Abstract/SqlBuilderProvider/InsertBuilder.cs @@ -280,7 +280,7 @@ namespace SqlSugar } private int GetDbColumnIndex = 0; - public virtual string GetDbColumn(DbColumnInfo columnInfo ,object name) + public virtual string GetDbColumn(DbColumnInfo columnInfo ,object name) { if (columnInfo.InsertServerTime) { @@ -296,11 +296,11 @@ namespace SqlSugar } else if (columnInfo.InsertSql.HasValue()) { - if (columnInfo.InsertSql.Contains("{0}")) + if (columnInfo.InsertSql.Contains("{0}")) { if (columnInfo.Value == null) { - return string.Format(columnInfo.InsertSql, "null").Replace("'null'","null"); + return string.Format(columnInfo.InsertSql, "null").Replace("'null'", "null"); } else { @@ -309,7 +309,7 @@ namespace SqlSugar } return columnInfo.InsertSql; } - else if (columnInfo.SqlParameterDbType is Type && (Type)columnInfo.SqlParameterDbType == UtilConstants.SqlConvertType) + else if (columnInfo.SqlParameterDbType is Type && IsNoParameterConvert(columnInfo)) { var type = columnInfo.SqlParameterDbType as Type; var ParameterConverter = type.GetMethod("ParameterConverter").MakeGenericMethod(typeof(string)); @@ -319,17 +319,17 @@ namespace SqlSugar } else if (columnInfo.SqlParameterDbType is Type) { - var type=columnInfo.SqlParameterDbType as Type; - var ParameterConverter=type.GetMethod("ParameterConverter").MakeGenericMethod(columnInfo.PropertyType); - var obj=Activator.CreateInstance(type); - var p = ParameterConverter.Invoke(obj,new object[] {columnInfo.Value, GetDbColumnIndex }) as SugarParameter; + var type = columnInfo.SqlParameterDbType as Type; + var ParameterConverter = type.GetMethod("ParameterConverter").MakeGenericMethod(columnInfo.PropertyType); + var obj = Activator.CreateInstance(type); + var p = ParameterConverter.Invoke(obj, new object[] { columnInfo.Value, GetDbColumnIndex }) as SugarParameter; GetDbColumnIndex++; //this.Parameters.RemoveAll(it => it.ParameterName == it.ParameterName); - UtilMethods.ConvertParameter(p,this.Builder); + UtilMethods.ConvertParameter(p, this.Builder); this.Parameters.Add(p); return p.ParameterName; } - else if (columnInfo.DataType?.Equals("nvarchar2")==true) + else if (columnInfo.DataType?.Equals("nvarchar2") == true) { var pname = Builder.SqlParameterKeyWord + columnInfo.DbColumnName + "_ts" + GetDbColumnIndex; var p = new SugarParameter(pname, columnInfo.Value); @@ -338,7 +338,7 @@ namespace SqlSugar GetDbColumnIndex++; return pname; } - else if (columnInfo.PropertyType!=null&&columnInfo.PropertyType.Name == "TimeOnly" ) + else if (columnInfo.PropertyType != null && columnInfo.PropertyType.Name == "TimeOnly") { var timeSpan = UtilMethods.TimeOnlyToTimeSpan(columnInfo.Value); var pname = Builder.SqlParameterKeyWord + columnInfo.DbColumnName + "_ts" + GetDbColumnIndex; @@ -352,7 +352,7 @@ namespace SqlSugar var pname = Builder.SqlParameterKeyWord + columnInfo.DbColumnName + "_ts" + GetDbColumnIndex; if (timeSpan == null) { - this.Parameters.Add(new SugarParameter(pname, null) { DbType=System.Data.DbType.Date }); + this.Parameters.Add(new SugarParameter(pname, null) { DbType = System.Data.DbType.Date }); } else { @@ -376,6 +376,19 @@ namespace SqlSugar } } + private static bool IsNoParameterConvert(DbColumnInfo columnInfo) + { + if (columnInfo.SqlParameterDbType is Type t) + { + var isAssignableFrom = typeof(DbConvert.NoParameterCommonPropertyConvert).IsAssignableFrom(t); + if (isAssignableFrom) + { + return isAssignableFrom; + } + } + return (Type)columnInfo.SqlParameterDbType == UtilConstants.SqlConvertType; + } + #endregion } } diff --git a/Src/Asp.Net/SqlSugar/Abstract/SqlBuilderProvider/QueryBuilder.cs b/Src/Asp.Net/SqlSugar/Abstract/SqlBuilderProvider/QueryBuilder.cs index f49cc18f2..38e033ae0 100644 --- a/Src/Asp.Net/SqlSugar/Abstract/SqlBuilderProvider/QueryBuilder.cs +++ b/Src/Asp.Net/SqlSugar/Abstract/SqlBuilderProvider/QueryBuilder.cs @@ -33,7 +33,8 @@ namespace SqlSugar public ISqlBuilder Builder { get; set; } #endregion - #region Splicing basic + #region Splicing basic + public Type AsType { get; set; } public bool IsParameterizedConstructor { get; set; } public string Hints { get; set; } internal AppendNavInfo AppendNavInfo { get; set; } diff --git a/Src/Asp.Net/SqlSugar/Abstract/SqlBuilderProvider/SqlBuilderProvider.cs b/Src/Asp.Net/SqlSugar/Abstract/SqlBuilderProvider/SqlBuilderProvider.cs index 96b007d8e..779877e99 100644 --- a/Src/Asp.Net/SqlSugar/Abstract/SqlBuilderProvider/SqlBuilderProvider.cs +++ b/Src/Asp.Net/SqlSugar/Abstract/SqlBuilderProvider/SqlBuilderProvider.cs @@ -31,11 +31,11 @@ namespace SqlSugar #region abstract Methods - public virtual bool SupportReadToken { get; set; } + public virtual bool SupportReadToken { get; set; } = true; public virtual Task GetReaderByToken(IDataReader dataReader, CancellationToken cancellationToken) { - return ((DbDataReader)dataReader).ReadAsync(); + return ((DbDataReader)dataReader).ReadAsync(cancellationToken); } public virtual void ChangeJsonType(SugarParameter paramter) { diff --git a/Src/Asp.Net/SqlSugar/Abstract/SqlBuilderProvider/UpdateBuilder.cs b/Src/Asp.Net/SqlSugar/Abstract/SqlBuilderProvider/UpdateBuilder.cs index 66db7217f..1761f49c3 100644 --- a/Src/Asp.Net/SqlSugar/Abstract/SqlBuilderProvider/UpdateBuilder.cs +++ b/Src/Asp.Net/SqlSugar/Abstract/SqlBuilderProvider/UpdateBuilder.cs @@ -458,11 +458,11 @@ namespace SqlSugar { return LambdaExpressions.DbMehtods.GetDate(); } - else if (columnInfo.PropertyType.FullName == "NetTopologySuite.Geometries.Geometry") + else if (columnInfo.PropertyType.FullName == "NetTopologySuite.Geometries.Geometry") { var pname = Builder.SqlParameterKeyWord + "Geometry" + GetDbColumnIndex; var p = new SugarParameter(pname, columnInfo.Value); - p.DbType= System.Data.DbType.Object; + p.DbType = System.Data.DbType.Object; this.Parameters.Add(p); GetDbColumnIndex++; return pname; @@ -501,7 +501,7 @@ namespace SqlSugar } return columnInfo.UpdateSql; } - else if (columnInfo.SqlParameterDbType is Type && (Type)columnInfo.SqlParameterDbType == UtilConstants.SqlConvertType) + else if (columnInfo.SqlParameterDbType is Type && IsNoParameterConvert(columnInfo)) { var type = columnInfo.SqlParameterDbType as Type; var ParameterConverter = type.GetMethod("ParameterConverter").MakeGenericMethod(typeof(string)); @@ -564,6 +564,20 @@ namespace SqlSugar return name + ""; } } + + private static bool IsNoParameterConvert(DbColumnInfo columnInfo) + { + if (columnInfo.SqlParameterDbType is Type t) + { + var isAssignableFrom = typeof(DbConvert.NoParameterCommonPropertyConvert).IsAssignableFrom(t); + if (isAssignableFrom) + { + return isAssignableFrom; + } + } + return (Type)columnInfo.SqlParameterDbType == UtilConstants.SqlConvertType; + } + private bool IsSingleSetExp(DbColumnInfo columnInfo) { return this.ReSetValueBySqlExpList != null && diff --git a/Src/Asp.Net/SqlSugar/Abstract/UpdateProvider/UpdateableHelper.cs b/Src/Asp.Net/SqlSugar/Abstract/UpdateProvider/UpdateableHelper.cs index b084f17ff..9a48c26e7 100644 --- a/Src/Asp.Net/SqlSugar/Abstract/UpdateProvider/UpdateableHelper.cs +++ b/Src/Asp.Net/SqlSugar/Abstract/UpdateProvider/UpdateableHelper.cs @@ -881,6 +881,10 @@ namespace SqlSugar { return UtilMethods.CountSubstringOccurrences(sql,"WHERE")>1; } + private bool IsCorrectErrorSqlParameterName() + { + return this.Context?.CurrentConnectionConfig?.MoreSettings?.IsCorrectErrorSqlParameterName == true; + } private void ThrowUpdateByExpression() { diff --git a/Src/Asp.Net/SqlSugar/Abstract/UpdateProvider/UpdateableProvider.cs b/Src/Asp.Net/SqlSugar/Abstract/UpdateProvider/UpdateableProvider.cs index d5fc84db6..aebb2f978 100644 --- a/Src/Asp.Net/SqlSugar/Abstract/UpdateProvider/UpdateableProvider.cs +++ b/Src/Asp.Net/SqlSugar/Abstract/UpdateProvider/UpdateableProvider.cs @@ -860,6 +860,10 @@ namespace SqlSugar UpdateBuilder.LambdaExpressions.ParameterIndex = 100; } var expResult = UpdateBuilder.GetExpressionValue(columns, ResolveExpressType.WhereSingle).GetResultString().Replace(")", " )").Replace("(", "( ").Trim().TrimStart('(').TrimEnd(')').Replace("= =","="); + if (IsCorrectErrorSqlParameterName()) + { + expResult = UpdateBuilder.GetExpressionValue(binaryExp.Right, ResolveExpressType.WhereSingle).GetResultString().Trim(); + } if (expResult.EndsWith(" IS NULL ")) { expResult = Regex.Split(expResult, " IS NULL ")[0]+" = NULL "; @@ -869,7 +873,11 @@ namespace SqlSugar expResult = Regex.Split(expResult, "IS NULL ")[0] + " = NULL "; } string key = SqlBuilder.GetNoTranslationColumnName(expResult); - + if (IsCorrectErrorSqlParameterName()&& binaryExp.Left is MemberExpression member) + { + key =this.EntityInfo.Columns.First(it=>it.PropertyName== member.Member.Name).DbColumnName; + expResult = $" {this.SqlBuilder.GetTranslationColumnName(key)}={expResult} "; + } if (EntityInfo.Columns.Where(it=>it.IsJson||it.IsTranscoding).Any(it => it.DbColumnName.EqualCase(key) || it.PropertyName.EqualCase(key))) { CheckTranscodeing(); diff --git a/Src/Asp.Net/SqlSugar/ExpressionsToSql/DbMethods/DefaultDbMethod.cs b/Src/Asp.Net/SqlSugar/ExpressionsToSql/DbMethods/DefaultDbMethod.cs index eaed612d9..760e70235 100644 --- a/Src/Asp.Net/SqlSugar/ExpressionsToSql/DbMethods/DefaultDbMethod.cs +++ b/Src/Asp.Net/SqlSugar/ExpressionsToSql/DbMethods/DefaultDbMethod.cs @@ -426,6 +426,11 @@ namespace SqlSugar var parameter = model.Args[0]; return string.Format("COUNT(DISTINCT {0} )", parameter.MemberName); } + public virtual string AggregateDistinctSum(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + return string.Format("SUM(DISTINCT {0} )", parameter.MemberName); + } public virtual string MappingColumn(MethodCallExpressionModel model) { @@ -1195,7 +1200,12 @@ namespace SqlSugar { return $" uuid_generate_v4() "; } - + public virtual string Coalesce(MethodCallExpressionModel mode) + { + var parameterNameA = mode.Args[0].MemberName; + var parameterNameB = mode.Args[1].MemberName; + return $" COALESCE({parameterNameA},{parameterNameB}) "; + } public virtual string FullTextContains(MethodCallExpressionModel mode) { var columns = mode.Args[0].MemberName; diff --git a/Src/Asp.Net/SqlSugar/ExpressionsToSql/DbMethods/IDbMethods.cs b/Src/Asp.Net/SqlSugar/ExpressionsToSql/DbMethods/IDbMethods.cs index 0561caf12..aeb0578a2 100644 --- a/Src/Asp.Net/SqlSugar/ExpressionsToSql/DbMethods/IDbMethods.cs +++ b/Src/Asp.Net/SqlSugar/ExpressionsToSql/DbMethods/IDbMethods.cs @@ -54,6 +54,7 @@ namespace SqlSugar string AggregateMax(MethodCallExpressionModel model); string AggregateCount(MethodCallExpressionModel model); string AggregateDistinctCount(MethodCallExpressionModel model); + string AggregateDistinctSum(MethodCallExpressionModel model); string MappingColumn(MethodCallExpressionModel model); string IsNull(MethodCallExpressionModel model); string GetSelfAndAutoFill(string shortName,bool isSingle); @@ -129,5 +130,6 @@ namespace SqlSugar string FullTextContains(MethodCallExpressionModel mode); string PgsqlArrayContains(MethodCallExpressionModel model); string SelectFields(MethodCallExpressionModel model); + string Coalesce(MethodCallExpressionModel model); } } diff --git a/Src/Asp.Net/SqlSugar/ExpressionsToSql/DbMethods/SqlFunc.cs b/Src/Asp.Net/SqlSugar/ExpressionsToSql/DbMethods/SqlFunc.cs index 0062a5f05..8f2b95b76 100644 --- a/Src/Asp.Net/SqlSugar/ExpressionsToSql/DbMethods/SqlFunc.cs +++ b/Src/Asp.Net/SqlSugar/ExpressionsToSql/DbMethods/SqlFunc.cs @@ -10,6 +10,11 @@ namespace SqlSugar { public partial class SqlFunc { + + public static T Coalesce(T value1, T value2) + { + throw new NotSupportedException("Can only be used in expressions"); + } public static bool FullTextContains(string [] columnNames, string keyword) { throw new NotSupportedException("Can only be used in expressions"); @@ -360,6 +365,7 @@ namespace SqlSugar public static TResult AggregateMax(TResult thisValue) { throw new NotSupportedException("Can only be used in expressions"); } public static int AggregateCount(TResult thisValue) { throw new NotSupportedException("Can only be used in expressions"); } public static int AggregateDistinctCount(TResult thisValue) { throw new NotSupportedException("Can only be used in expressions"); } + public static int AggregateDistinctSum(TResult thisValue) { throw new NotSupportedException("Can only be used in expressions"); } public static TResult MappingColumn(TResult type,string newColumnName) { throw new NotSupportedException("Can only be used in expressions"); } public static TResult MappingColumn(string newColumnName) { throw new NotSupportedException("Can only be used in expressions"); } /// diff --git a/Src/Asp.Net/SqlSugar/ExpressionsToSql/ResolveItems/MemberExpressionResolve.cs b/Src/Asp.Net/SqlSugar/ExpressionsToSql/ResolveItems/MemberExpressionResolve.cs index f4c64f629..2f81a0d1e 100644 --- a/Src/Asp.Net/SqlSugar/ExpressionsToSql/ResolveItems/MemberExpressionResolve.cs +++ b/Src/Asp.Net/SqlSugar/ExpressionsToSql/ResolveItems/MemberExpressionResolve.cs @@ -626,6 +626,7 @@ namespace SqlSugar } var result = this.Context.DbMehtods.DateValue(new MethodCallExpressionModel() { + Conext=this.Context, Args = new List() { new MethodCallExpressionArgs() { IsMember = !isConst, MemberName = parameter.CommonTempData, MemberValue = null }, new MethodCallExpressionArgs() { IsMember = true, MemberName = name, MemberValue = name } @@ -795,6 +796,10 @@ namespace SqlSugar fieldName = fieldName.Replace(UtilConstants.Space, guid); } fieldName = Context.GetTranslationColumnName(fieldName); + if (this.Context?.SugarContext?.Context?.CurrentConnectionConfig?.MoreSettings?.IsCorrectErrorSqlParameterName == true&& fieldName?.Contains(ExpressionConst.LeftParenthesis)==true) + { + fieldName = Context.GetTranslationText(fieldName); + } if (isSpace) { fieldName = fieldName.Replace(guid, UtilConstants.Space); diff --git a/Src/Asp.Net/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve_Helper.cs b/Src/Asp.Net/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve_Helper.cs index 8a76bd577..61d8a3b0a 100644 --- a/Src/Asp.Net/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve_Helper.cs +++ b/Src/Asp.Net/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve_Helper.cs @@ -870,6 +870,10 @@ namespace SqlSugar } return result1; case "GetDate": + if (this.Context?.SugarContext?.Context?.CurrentConnectionConfig?.MoreSettings?.DatabaseModel == DbType.SqlServer) + { + return "GetDate()"; + } return this.Context.DbMehtods.GetDate(); case "GetRandom": return this.Context.DbMehtods.GetRandom(); diff --git a/Src/Asp.Net/SqlSugar/Infrastructure/InstanceFactory.cs b/Src/Asp.Net/SqlSugar/Infrastructure/InstanceFactory.cs index 6cf8197b6..891ad9b03 100644 --- a/Src/Asp.Net/SqlSugar/Infrastructure/InstanceFactory.cs +++ b/Src/Asp.Net/SqlSugar/Infrastructure/InstanceFactory.cs @@ -45,6 +45,10 @@ namespace SqlSugar { return new MySqlQueryable(); } + else if (currentConnectionConfig.DbType == DbType.Sqlite) + { + return new SqliteQueryable(); + } else if (currentConnectionConfig.DbType == DbType.PostgreSQL) { return new PostgreSQLQueryable(); diff --git a/Src/Asp.Net/SqlSugar/Interface/IQueryable.cs b/Src/Asp.Net/SqlSugar/Interface/IQueryable.cs index b9b1a253a..b0221f41b 100644 --- a/Src/Asp.Net/SqlSugar/Interface/IQueryable.cs +++ b/Src/Asp.Net/SqlSugar/Interface/IQueryable.cs @@ -22,6 +22,7 @@ namespace SqlSugar ISugarQueryable AS(string tableName); ISugarQueryable AsWithAttr(); ISugarQueryable AsType(Type tableNameType); + ISugarQueryable Cast(); ISugarQueryable With(string withString); //ISugarQueryable CrossQueryWithAttr(); ISugarQueryable CrossQuery(string configId);