diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbBindProvider/DbBindProvider.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbBindProvider/DbBindProvider.cs index 7fe1fe2c0..7db20d88f 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbBindProvider/DbBindProvider.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbBindProvider/DbBindProvider.cs @@ -18,16 +18,14 @@ namespace SqlSugar public virtual string GetDbTypeName(string csharpTypeName) { if (csharpTypeName == UtilConstants.ByteArrayType.Name) - { return "varbinary"; - } - if (csharpTypeName == "Int32") + if (csharpTypeName.ToLower() == "int32") csharpTypeName = "int"; - if (csharpTypeName == "Int16") + if (csharpTypeName.ToLower() == "int16") csharpTypeName = "short"; - if (csharpTypeName == "Int64") + if (csharpTypeName.ToLower() == "int64") csharpTypeName = "long"; - if (csharpTypeName == "Boolean") + if (csharpTypeName.ToLower().IsIn("boolean", "bool")) csharpTypeName = "bool"; var mappings = this.MappingTypes.Where(it => it.Value.ToString().Equals(csharpTypeName, StringComparison.CurrentCultureIgnoreCase)); return mappings.HasValue() ? mappings.First().Key : "varchar"; @@ -151,7 +149,7 @@ namespace SqlSugar { return "long"; } - else if (dbTypeName == "int16") + else if (dbTypeName == "int16") { return "short"; } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbBindProvider/IDataReaderEntityBuilder.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbBindProvider/IDataReaderEntityBuilder.cs index 1cf4e2fb8..4c8ad3757 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbBindProvider/IDataReaderEntityBuilder.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/DbBindProvider/IDataReaderEntityBuilder.cs @@ -222,7 +222,7 @@ namespace SqlSugar if (bindProperyTypeName.IsContainsIn("int", "int32")) method = isNullableType ? getConvertInt32 : getInt32; if (bindProperyTypeName.IsContainsIn("int64")) - method = isNullableType ? getConvertInt64 : getInt64; + method = isNullableType ? getConvertInt32 : getInt32; if (bindProperyTypeName.IsContainsIn("byte")) method = isNullableType ? getConvertByte : getByte; if (bindProperyTypeName.IsContainsIn("int16")) diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/InsertBuilder.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/InsertBuilder.cs index 0fcb158a2..82e92a3ea 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/InsertBuilder.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/InsertBuilder.cs @@ -166,6 +166,11 @@ namespace SqlSugar } return "'" + date.ToString("yyyy-MM-dd HH:mm:ss.fff") + "'"; } + else if (type == UtilConstants.ByteArrayType) + { + string bytesString = "0x" + BitConverter.ToString((byte[])value); + return bytesString; + } else if (type.IsEnum()) { return Convert.ToInt64(value); diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/UpdateBuilder.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/UpdateBuilder.cs index 692f1b064..dbaf3fbdc 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/UpdateBuilder.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Abstract/SqlBuilderProvider/UpdateBuilder.cs @@ -175,7 +175,7 @@ namespace SqlSugar { updateTable.Append(SqlTemplateBatchUnion); } - updateTable.Append("\r\n SELECT " + string.Join(",", columns.Select(it => string.Format(SqlTemplateBatchSelect, FormatValue(it.Value),Builder.GetTranslationColumnName(it.DbColumnName))))); + updateTable.Append("\r\n SELECT " + string.Join(",", columns.Select(it => string.Format(SqlTemplateBatchSelect, FormatValue(it.Value), Builder.GetTranslationColumnName(it.DbColumnName))))); ++i; } pageIndex++; @@ -210,7 +210,7 @@ namespace SqlSugar { if (SetValues.IsValuable()) { - var setValue = SetValues.Where(sv => it.IsPrimarykey == false && (it.IsIdentity == false || (IsOffIdentity && it.IsIdentity))).Where(sv => sv.Key == Builder.GetTranslationColumnName(it.DbColumnName)|| sv.Key==Builder.GetTranslationColumnName(it.PropertyName)); + var setValue = SetValues.Where(sv => it.IsPrimarykey == false && (it.IsIdentity == false || (IsOffIdentity && it.IsIdentity))).Where(sv => sv.Key == Builder.GetTranslationColumnName(it.DbColumnName) || sv.Key == Builder.GetTranslationColumnName(it.PropertyName)); if (setValue != null && setValue.Any()) { return setValue.First().Value; @@ -259,6 +259,11 @@ namespace SqlSugar } return "'" + date.ToString("yyyy-MM-dd HH:mm:ss.fff") + "'"; } + else if (type == UtilConstants.ByteArrayType) + { + string bytesString = "0x" + BitConverter.ToString((byte[])value); + return bytesString; + } else if (type.IsEnum()) { return Convert.ToInt64(value); diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Enum/ConditionalType.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Enum/ConditionalType.cs index 2a4a691b5..d316c0a90 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Enum/ConditionalType.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Enum/ConditionalType.cs @@ -12,6 +12,12 @@ namespace SqlSugar GreaterThan =2, GreaterThanOrEqual = 3, LessThan=4, - LessThanOrEqual = 5 + LessThanOrEqual = 5, + In=6, + NotIn=7, + LikeLeft=8, + LikeRight=9, + NoEqual=10, + IsNullOrEmpty=11 } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/CaseWhen/CaseWhen.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/CaseWhen/CaseWhen.cs new file mode 100644 index 000000000..3e74788e5 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/CaseWhen/CaseWhen.cs @@ -0,0 +1,28 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Linq.Expressions; +using System.Text; + +namespace SqlSugar +{ + public class CaseWhen + { + public CaseThen ElseIF(bool condition) + { + return null; + } + public T End(T defaultValue) + { + return default(T); + } + } + public class CaseThen + { + + public CaseWhen Return(T result) + { + return null; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/CaseWhen/CaseWhenResolve.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/CaseWhen/CaseWhenResolve.cs new file mode 100644 index 000000000..94b92c39d --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/CaseWhen/CaseWhenResolve.cs @@ -0,0 +1,52 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Linq.Expressions; +using System.Text; + +namespace SqlSugar +{ + + public class CaseWhenResolve + { + List allMethods = new List(); + private ExpressionContext context = null; + public CaseWhenResolve(MethodCallExpression expression, ExpressionContext context, Expression oppsiteExpression) + { + this.context = context; + var currentExpression = expression; + allMethods.Add(currentExpression); + if (context.IsSingle && oppsiteExpression != null&& oppsiteExpression is MemberExpression) + { + var childExpression = (oppsiteExpression as MemberExpression).Expression; + this.context.SingleTableNameSubqueryShortName = (childExpression as ParameterExpression).Name; + } + else if (context.IsSingle) + { + this.context.SingleTableNameSubqueryShortName = (context.Expression as LambdaExpression).Parameters.First().Name; + } + while (currentExpression != null) + { + var addItem = currentExpression.Object as MethodCallExpression; + if (addItem != null) + allMethods.Add(addItem); + currentExpression = addItem; + } + } + + public string GetSql() + { + allMethods.Reverse(); + List> sqls = new List>(); + foreach (var methodExp in allMethods) + { + var isFirst = allMethods.First() == methodExp; + var isLast= allMethods.Last() == methodExp; + var sql= SubTools.GetMethodValue(this.context, methodExp.Arguments[0],this.context.IsSingle?ResolveExpressType.WhereSingle:ResolveExpressType.WhereMultiple); + sqls.Add(new KeyValuePair(methodExp.Method.Name, sql)); + } + var result= this.context.DbMehtods.CaseWhen(sqls); + return result; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Common/ErrorMessage.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Common/ErrorMessage.cs index b64176e27..fe73cb1e0 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Common/ErrorMessage.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Common/ErrorMessage.cs @@ -34,7 +34,7 @@ namespace SqlSugar { get { - return ErrorMessage.GetThrowMessage("Connection open error . {0}", " 连接字符串出错了，实在找不到原因请先Google错误{0}."); + return ErrorMessage.GetThrowMessage("Connection open error . {0}", " 连接数据库过程中发生错误，检查服务器是否正常连接字符串是否正确，实在找不到原因请先Google错误信息：{0}."); } } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Common/ExpressionTool.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Common/ExpressionTool.cs index fae3ce837..09778df27 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Common/ExpressionTool.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Common/ExpressionTool.cs @@ -41,6 +41,8 @@ namespace SqlSugar case ExpressionType.Multiply: case ExpressionType.MultiplyChecked: return "*"; + case ExpressionType.Coalesce: + throw new Exception("Expression no support ?? ,Use SqlFunc.IsNull"); default: Check.ThrowNotSupportedException(string.Format(ErrorMessage.OperatorError, expressiontype.ToString())); return null; diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/DefaultDbMethod.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/DefaultDbMethod.cs index bdfc85e6a..6b0624d93 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/DefaultDbMethod.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/DefaultDbMethod.cs @@ -271,6 +271,13 @@ namespace SqlSugar return string.Format("{0}", parameter1.MemberValue); } + public virtual string IsNull(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + var parameter1 = model.Args[1]; + return string.Format("ISNULL({0},{1})", parameter.MemberName, parameter1.MemberName); + } + public virtual string True() { return "( 1 = 1 ) "; @@ -295,7 +302,7 @@ namespace SqlSugar public virtual string MergeString(params string[] strings) { - return string.Join("", strings); + return string.Join("+", strings); } public virtual string Pack(string sql) @@ -312,5 +319,34 @@ namespace SqlSugar { return "NULL"; } + + public virtual string GetDate() + { + return "GETDATE()"; + } + + public virtual string CaseWhen(List> sqls) + { + StringBuilder reslut = new StringBuilder(); + foreach (var item in sqls) + { + if (item.Key == "IF") + { + reslut.AppendFormat(" ( CASE WHEN {0} ", item.Value); + } + else if (item.Key == "End") + { + reslut.AppendFormat("ELSE {0} END )", item.Value); + } + else if (item.Key == "Return") + { + reslut.AppendFormat(" THEN {0} ", item.Value); + } + else { + reslut.AppendFormat(" WHEN {0} ", item.Value); + } + } + return reslut.ToString(); + } } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/IDbMethods.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/IDbMethods.cs index 1246de45f..0e800a6ef 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/IDbMethods.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/IDbMethods.cs @@ -36,6 +36,7 @@ namespace SqlSugar string ToGuid(MethodCallExpressionModel model); string ToDouble(MethodCallExpressionModel model); string ToBool(MethodCallExpressionModel model); + string CaseWhen(List> sqls); string Substring(MethodCallExpressionModel model); string ToDate(MethodCallExpressionModel model); string ToTime(MethodCallExpressionModel model); @@ -48,6 +49,7 @@ namespace SqlSugar string AggregateMax(MethodCallExpressionModel model); string AggregateCount(MethodCallExpressionModel model); string MappingColumn(MethodCallExpressionModel model); + string IsNull(MethodCallExpressionModel model); string GetSelfAndAutoFill(string shortName,bool isSingle); string True(); string False(); @@ -56,5 +58,6 @@ namespace SqlSugar string EqualTrue(string value); string Pack(string sql); string Null(); + string GetDate(); } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/SqlFunc.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/SqlFunc.cs index 463fd2867..8d68265aa 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/SqlFunc.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/DbMethods/SqlFunc.cs @@ -67,6 +67,13 @@ namespace SqlSugar public static int DateValue(DateTime date, DateType dataType) { throw new NotSupportedException("Can only be used in expressions"); } public static bool Between(object value, object start, object end) { throw new NotSupportedException("Can only be used in expressions"); } public static TResult IIF(bool Expression, TResult thenValue, TResult elseValue) { throw new NotSupportedException("Can only be used in expressions"); } + public static TResult IsNull(TResult thisValue, TResult ifNullValue) { throw new NotSupportedException("Can only be used in expressions"); } + public static string MergeString(string value1,string value2) { throw new NotSupportedException("Can only be used in expressions"); } + public static string MergeString(string value1, string value2,string value3) { throw new NotSupportedException("Can only be used in expressions"); } + public static string MergeString(string value1, string value2,string value3,string value4) { throw new NotSupportedException("Can only be used in expressions"); } + public static string MergeString(string value1, string value2, string value3, string value4,string value5) { throw new NotSupportedException("Can only be used in expressions"); } + public static string MergeString(string value1, string value2, string value3, string value4, string value5,string value6) { throw new NotSupportedException("Can only be used in expressions"); } + public static string MergeString(string value1, string value2, string value3, string value4, string value5, string value6,string value7) { throw new NotSupportedException("Can only be used in expressions"); } public static int ToInt32(object value) { return value.ObjToInt(); } public static long ToInt64(object value) { return Convert.ToInt64(value); } /// @@ -102,11 +109,13 @@ namespace SqlSugar /// /// public static TResult GetSelfAndAutoFill(TResult value) { throw new NotSupportedException("Can only be used in expressions"); } + public static DateTime GetDate() { throw new NotSupportedException("Can only be used in expressions"); } /// /// Subquery /// /// /// public static Subqueryable Subqueryable() where T:class,new(){ throw new NotSupportedException("Can only be used in expressions");} + public static CaseThen IF(bool condition) { throw new NotSupportedException("Can only be used in expressions"); } } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/LambdaExpressionResolve.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/LambdaExpressionResolve.cs index 9023cf3f6..fa63291dc 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/LambdaExpressionResolve.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/LambdaExpressionResolve.cs @@ -12,6 +12,9 @@ namespace SqlSugar LambdaExpression lambda = base.Expression as LambdaExpression; var expression = lambda.Body; base.Expression = expression; + if (parameter.Context.ResolveType.IsIn(ResolveExpressType.FieldMultiple, ResolveExpressType.FieldSingle)) { + parameter.CommonTempData = CommonTempDataType.Append; + } base.Start(); } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/MemberExpressionResolve.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/MemberExpressionResolve.cs index 1866f8abb..1696abd80 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/MemberExpressionResolve.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/MemberExpressionResolve.cs @@ -10,24 +10,11 @@ namespace SqlSugar public ExpressionParameter Parameter { get; set; } public MemberExpressionResolve(ExpressionParameter parameter) : base(parameter) { - var baseParameter = parameter.BaseParameter; - var expression = base.Expression as MemberExpression; - var childExpression = expression.Expression as MemberExpression; - var memberName = expression.Member.Name; - var childIsMember = childExpression != null; - var isLeft = parameter.IsLeft; - var isSetTempData = parameter.IsSetTempData; - var isValue = memberName == "Value" && expression.Member.DeclaringType.Name == "Nullable`1"; - var isBool = expression.Type == UtilConstants.BoolType; - var isValueBool = isValue && isBool && parameter.BaseExpression == null; - var isLength = memberName == "Length" && childIsMember && childExpression.Type == UtilConstants.StringType; - var isDateValue = memberName.IsIn(Enum.GetNames(typeof(DateType))) && (childIsMember && childExpression.Type == UtilConstants.DateType); - var isLogicOperator = ExpressionTool.IsLogicOperator(baseParameter.OperatorValue) || baseParameter.OperatorValue.IsNullOrEmpty(); - var isHasValue = isLogicOperator && memberName == "HasValue" && expression.Expression != null && expression.NodeType == ExpressionType.MemberAccess; - var isDateDate = memberName == "Date" && expression.Expression.Type == UtilConstants.DateType; - var isMemberValue = expression.Expression != null && expression.Expression.NodeType != ExpressionType.Parameter && !isValueBool; - var isSingle = parameter.Context.ResolveType == ResolveExpressType.WhereSingle; - var fieldIsBool = isBool && isLogicOperator&&(parameter.BaseParameter==null||!(parameter.BaseParameter.CurrentExpression is MemberInitExpression|| parameter.BaseParameter.CurrentExpression is NewExpression)); + ExpressionParameter baseParameter; + MemberExpression expression; + bool? isLeft; + bool isSetTempData, isValue, isValueBool, isLength, isDateValue, isHasValue, isDateDate, isMemberValue, isSingle, fieldIsBool, isSelectField, isField; + SettingParameters(parameter, out baseParameter, out expression, out isLeft, out isSetTempData, out isValue, out isValueBool, out isLength, out isDateValue, out isHasValue, out isDateDate, out isMemberValue, out isSingle, out fieldIsBool, out isSelectField, out isField); baseParameter.ChildExpression = expression; if (isLength) { @@ -57,52 +44,60 @@ namespace SqlSugar { ResolveMemberValue(parameter, baseParameter, isLeft, isSetTempData, expression); } - else if (fieldIsBool&& !this.Context.ResolveType.IsIn(ResolveExpressType.FieldSingle, ResolveExpressType.FieldMultiple)) + else if (fieldIsBool && !isField && !isSelectField) { ResolvefieldIsBool(parameter, baseParameter, isLeft, isSetTempData, expression, isSingle); } else { - string fieldName = string.Empty; - switch (parameter.Context.ResolveType) - { - case ResolveExpressType.SelectSingle: - fieldName = GetSingleName(parameter, expression, isLeft); - if (isSetTempData) - baseParameter.CommonTempData = fieldName; - else - base.Context.Result.Append(fieldName); - break; - case ResolveExpressType.SelectMultiple: - fieldName = GetMultipleName(parameter, expression, isLeft); - if (isSetTempData) - baseParameter.CommonTempData = fieldName; - else - base.Context.Result.Append(fieldName); - break; - case ResolveExpressType.WhereSingle: - case ResolveExpressType.WhereMultiple: - ResolveWhereLogic(parameter, baseParameter, expression, isLeft, isSetTempData, isSingle); - break; - case ResolveExpressType.FieldSingle: - fieldName = GetSingleName(parameter, expression, isLeft); - base.Context.Result.Append(fieldName); - break; - case ResolveExpressType.FieldMultiple: - fieldName = GetMultipleName(parameter, expression, isLeft); - base.Context.Result.Append(fieldName); - break; - case ResolveExpressType.ArrayMultiple: - case ResolveExpressType.ArraySingle: - fieldName = GetName(parameter, expression, isLeft, parameter.Context.ResolveType == ResolveExpressType.ArraySingle); - base.Context.Result.Append(fieldName); - break; - default: - break; - } + ResolveDefault(parameter, baseParameter, expression, isLeft, isSetTempData, isSingle); } } + #region Resolve default + private void ResolveDefault(ExpressionParameter parameter, ExpressionParameter baseParameter, MemberExpression expression, bool? isLeft, bool isSetTempData, bool isSingle) + { + string fieldName = string.Empty; + switch (parameter.Context.ResolveType) + { + case ResolveExpressType.SelectSingle: + fieldName = GetSingleName(parameter, expression, isLeft); + if (isSetTempData) + baseParameter.CommonTempData = fieldName; + else + base.Context.Result.Append(fieldName); + break; + case ResolveExpressType.SelectMultiple: + fieldName = GetMultipleName(parameter, expression, isLeft); + if (isSetTempData) + baseParameter.CommonTempData = fieldName; + else + base.Context.Result.Append(fieldName); + break; + case ResolveExpressType.WhereSingle: + case ResolveExpressType.WhereMultiple: + ResolveWhereLogic(parameter, baseParameter, expression, isLeft, isSetTempData, isSingle); + break; + case ResolveExpressType.FieldSingle: + fieldName = GetSingleName(parameter, expression, isLeft); + base.Context.Result.Append(fieldName); + break; + case ResolveExpressType.FieldMultiple: + fieldName = GetMultipleName(parameter, expression, isLeft); + base.Context.Result.Append(fieldName); + break; + case ResolveExpressType.ArrayMultiple: + case ResolveExpressType.ArraySingle: + fieldName = GetName(parameter, expression, isLeft, parameter.Context.ResolveType == ResolveExpressType.ArraySingle); + base.Context.Result.Append(fieldName); + break; + default: + break; + } + } + + #endregion + #region Resolve Where private void ResolveWhereLogic(ExpressionParameter parameter, ExpressionParameter baseParameter, MemberExpression expression, bool? isLeft, bool isSetTempData, bool isSingle) { @@ -112,7 +107,7 @@ namespace SqlSugar if (ExpressionTool.IsConstExpression(expression)) { var value = ExpressionTool.GetMemberValue(expression.Member, expression); - base.AppendValue(parameter, isLeft, value); + baseParameter.CommonTempData = value; } else { @@ -204,9 +199,9 @@ namespace SqlSugar }; AppendMember(parameter, isLeft, GetToDate(this.Context.DbMehtods.MergeString( this.GetDateValue(parameter.CommonTempData, DateType.Year), - "+'-'+", + "'-'", this.GetDateValue(parameter.CommonTempData, DateType.Month), - "+'-'+", + "'-'", this.GetDateValue(parameter.CommonTempData, DateType.Day)))); } parameter.CommonTempData = oldCommonTempDate; @@ -344,6 +339,33 @@ namespace SqlSugar }; return this.Context.DbMehtods.ToDate(pars); } + + private void SettingParameters(ExpressionParameter parameter, out ExpressionParameter baseParameter, out MemberExpression expression, out bool? isLeft, out bool isSetTempData, out bool isValue, out bool isValueBool, out bool isLength, out bool isDateValue, out bool isHasValue, out bool isDateDate, out bool isMemberValue, out bool isSingle, out bool fieldIsBool, out bool isSelectField, out bool isField) + { + baseParameter = parameter.BaseParameter; + expression = base.Expression as MemberExpression; + var childExpression = expression.Expression as MemberExpression; + var memberName = expression.Member.Name; + var childIsMember = childExpression != null; + var isRoot = parameter.BaseExpression == null; + isLeft = parameter.IsLeft; + isSetTempData = parameter.IsSetTempData; + isValue = memberName == "Value" && expression.Member.DeclaringType.Name == "Nullable`1"; + var isBool = expression.Type == UtilConstants.BoolType; + isValueBool = isValue && isBool && isRoot; + isLength = memberName == "Length" && childIsMember && childExpression.Type == UtilConstants.StringType; + isDateValue = memberName.IsIn(Enum.GetNames(typeof(DateType))) && (childIsMember && childExpression.Type == UtilConstants.DateType); + var isLogicOperator = ExpressionTool.IsLogicOperator(baseParameter.OperatorValue) || baseParameter.OperatorValue.IsNullOrEmpty(); + isHasValue = isLogicOperator && memberName == "HasValue" && expression.Expression != null && expression.NodeType == ExpressionType.MemberAccess; + isDateDate = memberName == "Date" && expression.Expression.Type == UtilConstants.DateType; + isMemberValue = expression.Expression != null && expression.Expression.NodeType != ExpressionType.Parameter && !isValueBool; + isSingle = parameter.Context.ResolveType == ResolveExpressType.WhereSingle; + fieldIsBool = isBool && isLogicOperator && (parameter.BaseParameter == null || !(parameter.BaseParameter.CurrentExpression is MemberInitExpression || parameter.BaseParameter.CurrentExpression is NewExpression)); + var isSelect = this.Context.ResolveType.IsIn(ResolveExpressType.SelectSingle, ResolveExpressType.SelectMultiple); + isSelectField = isSelect && isRoot; + isField = this.Context.ResolveType.IsIn(ResolveExpressType.FieldSingle, ResolveExpressType.FieldMultiple); + } + #endregion } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs index e1f8be3f1..00dcd94aa 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs @@ -45,7 +45,20 @@ namespace SqlSugar //Check.Exception(!(parameter.BaseExpression is BinaryExpression), "Current expressions are not supported"); SubResolve subResolve = new SubResolve(express, this.Context, parameter.OppsiteExpression); var appendSql = subResolve.GetSql(); - if (this.Context.ResolveType.IsIn(ResolveExpressType.SelectMultiple,ResolveExpressType.SelectSingle)) + if (this.Context.ResolveType.IsIn(ResolveExpressType.SelectMultiple, ResolveExpressType.SelectSingle)) + { + parameter.BaseParameter.CommonTempData = appendSql; + } + else + { + base.AppendValue(parameter, isLeft, appendSql); + } + return; + } + else if (IsIfElse(express, methodName)) { + CaseWhenResolve caseResole = new CaseWhenResolve(express, this.Context, parameter.OppsiteExpression); + var appendSql = caseResole.GetSql(); + if (this.Context.ResolveType.IsIn(ResolveExpressType.SelectMultiple, ResolveExpressType.SelectSingle)) { parameter.BaseParameter.CommonTempData = appendSql; } @@ -70,6 +83,14 @@ namespace SqlSugar } } + private bool IsIfElse(MethodCallExpression express, string methodName) + { + if (methodName == "End"&& express.Object.Type==typeof(CaseWhen)) + return true; + else + return false; + } + private void SqlFuncMethod(ExpressionParameter parameter, MethodCallExpression express, bool? isLeft) { CheckMethod(express); @@ -176,6 +197,13 @@ namespace SqlSugar model.Args.AddRange(appendArgs); } var methodValue = GetMdthodValue(name, model); + if (parameter.BaseExpression is BinaryExpression && parameter.OppsiteExpression.Type == UtilConstants.BoolType&&name=="HasValue") { + methodValue = this.Context.DbMehtods.CaseWhen(new List>() { + new KeyValuePair("IF",methodValue.ObjToString()), + new KeyValuePair("Return","1"), + new KeyValuePair("End","0") + }); + } base.AppendValue(parameter, isLeft, methodValue); } @@ -284,7 +312,7 @@ namespace SqlSugar base.Start(); var methodCallExpressionArgs = new MethodCallExpressionArgs() { - IsMember = parameter.ChildExpression is MemberExpression&&!ExpressionTool.IsConstExpression(parameter.ChildExpression as MemberExpression), + IsMember = parameter.ChildExpression is MemberExpression && !ExpressionTool.IsConstExpression(parameter.ChildExpression as MemberExpression), MemberName = parameter.CommonTempData }; if (methodCallExpressionArgs.IsMember && parameter.ChildExpression != null && parameter.ChildExpression.ToString() == "DateTime.Now") @@ -407,9 +435,15 @@ namespace SqlSugar Check.Exception(!isValid, "SqlFunc.MappingColumn parameters error, The property name on the left, string value on the right"); this.Context.Parameters.RemoveAll(it => it.ParameterName == model.Args[1].MemberName.ObjToString()); return mappingColumnResult; + case "IsNull": + return this.Context.DbMehtods.IsNull(model); + case "MergeString": + return this.Context.DbMehtods.MergeString(model.Args.Select(it=>it.MemberName.ObjToString()).ToArray()); case "GetSelfAndAutoFill": this.Context.Parameters.RemoveAll(it => it.ParameterName == model.Args[0].MemberName.ObjToString()); return this.Context.DbMehtods.GetSelfAndAutoFill(model.Args[0].MemberValue.ObjToString(), this.Context.IsSingle); + case "GetDate": + return this.Context.DbMehtods.GetDate(); default: break; } @@ -450,12 +484,12 @@ namespace SqlSugar { "AddMilliseconds",DateType.Millisecond} }; - private bool IsContainsArray(MethodCallExpression express, string methodName, bool isValidNativeMethod) + private bool IsContainsArray(MethodCallExpression express, string methodName, bool isValidNativeMethod) { return !isValidNativeMethod && express.Method.DeclaringType.Namespace.IsIn("System.Linq", "System.Collections.Generic") && methodName == "Contains"; } - private bool IsSubMethod(MethodCallExpression express, string methodName) + private bool IsSubMethod(MethodCallExpression express, string methodName) { return SubTools.SubItemsConst.Any(it => it.Name == methodName) && express.Object != null && express.Object.Type.Name == "Subqueryable`1"; } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/NewExpressionResolve.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/NewExpressionResolve.cs index 9c2e224b6..55f4c6566 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/NewExpressionResolve.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/ResolveItems/NewExpressionResolve.cs @@ -13,6 +13,7 @@ namespace SqlSugar public NewExpressionResolve(ExpressionParameter parameter) : base(parameter) { var expression = base.Expression as NewExpression; + Check.Exception(expression.Type == UtilConstants.GuidType, "Not Support new Guid(), Use Guid.New()"); switch (parameter.Context.ResolveType) { case ResolveExpressType.WhereSingle: diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Subquery/Items/SubAvg.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Subquery/Items/SubAvg.cs new file mode 100644 index 000000000..22daab138 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Subquery/Items/SubAvg.cs @@ -0,0 +1,44 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Linq.Expressions; +using System.Text; + +namespace SqlSugar +{ + public class SubAvg: ISubOperation + { + public string Name + { + get + { + return "Avg"; + } + } + + public Expression Expression + { + get; set; + } + + + public int Sort + { + get + { + return 200; + } + } + + public ExpressionContext Context + { + get; set; + } + + public string GetValue(Expression expression = null) + { + var exp = expression as MethodCallExpression; + return "AVG(" + SubTools.GetMethodValue(this.Context, exp.Arguments[0], ResolveExpressType.FieldSingle) + ")"; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Subquery/Items/SubSum.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Subquery/Items/SubSum.cs new file mode 100644 index 000000000..16563bba8 --- /dev/null +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Subquery/Items/SubSum.cs @@ -0,0 +1,44 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Linq.Expressions; +using System.Text; + +namespace SqlSugar +{ + public class SubSum:ISubOperation + { + public string Name + { + get + { + return "Sum"; + } + } + + public Expression Expression + { + get; set; + } + + + public int Sort + { + get + { + return 200; + } + } + + public ExpressionContext Context + { + get; set; + } + + public string GetValue(Expression expression = null) + { + var exp = expression as MethodCallExpression; + return "SUM("+SubTools.GetMethodValue(this.Context, exp.Arguments[0], ResolveExpressType.FieldSingle)+")"; + } + } +} diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Subquery/SubTools.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Subquery/SubTools.cs index 9697a03f0..d2aa6d923 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Subquery/SubTools.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Subquery/SubTools.cs @@ -23,6 +23,8 @@ namespace SqlSugar new SubCount(){ Context=Context }, new SubMax(){ Context=Context }, new SubMin(){ Context=Context }, + new SubSum(){ Context=Context }, + new SubAvg(){ Context=Context }, new SubOrderBy(){ Context=Context }, new SubOrderByDesc(){ Context=Context } }; diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Subquery/Subquerable.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Subquery/Subquerable.cs index 819c7b944..3be1178c1 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Subquery/Subquerable.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/ExpressionsToSql/Subquery/Subquerable.cs @@ -21,10 +21,15 @@ namespace SqlSugar { return this; } + public TResult Select(Func expression) where TResult :struct { return default(TResult); } + public Byte[] Select(Func expression) + { + return null; + } public string Select(Func expression) { return default(string); @@ -34,19 +39,54 @@ namespace SqlSugar { return default(TResult); } - - public TResult Min(Func expression) where TResult : struct + public Byte[] Max(Func expression) { - return default(TResult); + return null; } public string Max(Func expression) { return default(string); } + public string Min(Func expression) { return default(string); } + public TResult Min(Func expression) where TResult : struct + { + return default(TResult); + } + public Byte[] Min(Func expression) + { + return null; + } + + + public string Sum(Func expression) + { + return default(string); + } + public TResult Sum(Func expression) where TResult : struct + { + return default(TResult); + } + public Byte[] Sum(Func expression) + { + return null; + } + + public string Avg(Func expression) + { + return default(string); + } + public TResult Avg(Func expression) where TResult : struct + { + return default(TResult); + } + public Byte[] Avg(Func expression) + { + return null; + } public bool Any() { diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Infrastructure/ContextMethods.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Infrastructure/ContextMethods.cs index 7a1eb51f3..ed8402b80 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Infrastructure/ContextMethods.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Infrastructure/ContextMethods.cs @@ -140,12 +140,9 @@ namespace SqlSugar addValue = null; } } - else + else if (item.PropertyType == UtilConstants.IntType) { - if (item.PropertyType == UtilConstants.IntType) - { - addValue = Convert.ToInt32(addValue); - } + addValue = Convert.ToInt32(addValue); } result.Add(name, addValue); } @@ -330,6 +327,34 @@ namespace SqlSugar builder.AppendFormat(temp, type, item.FieldName.ToSqlFilter(), "<=", parameterName); parameters.Add(new SugarParameter(parameterName, item.FieldValue)); break; + case ConditionalType.In: + if (item.FieldValue == null) item.FieldValue = string.Empty; + var inValue1 = ("(" + item.FieldValue.Split(',').ToJoinSqlInVals() + ")"); + builder.AppendFormat(temp, type, item.FieldName.ToSqlFilter(), "IN", inValue1); + parameters.Add(new SugarParameter(parameterName, item.FieldValue)); + break; + case ConditionalType.NotIn: + if (item.FieldValue == null) item.FieldValue = string.Empty; + var inValue2 = ("(" + item.FieldValue.Split(',').ToJoinSqlInVals() + ")"); + builder.AppendFormat(temp, type, item.FieldName.ToSqlFilter(), "NOT IN", inValue2); + parameters.Add(new SugarParameter(parameterName, item.FieldValue)); + break; + case ConditionalType.LikeLeft: + builder.AppendFormat(temp, type, item.FieldName.ToSqlFilter(), "LIKE", parameterName); + parameters.Add(new SugarParameter(parameterName, item.FieldValue + "%")); + break; + case ConditionalType.LikeRight: + builder.AppendFormat(temp, type, item.FieldName.ToSqlFilter(), "LIKE", parameterName); + parameters.Add(new SugarParameter(parameterName, "%" + item.FieldValue)); + break; + case ConditionalType.NoEqual: + builder.AppendFormat(temp, type, item.FieldName.ToSqlFilter(), "<>", parameterName); + parameters.Add(new SugarParameter(parameterName, item.FieldValue)); + break; + case ConditionalType.IsNullOrEmpty: + builder.AppendFormat("{0} ({1}) OR ({2}) ", type, item.FieldName.ToSqlFilter() + " IS NULL ", item.FieldName.ToSqlFilter() + " = '' "); + parameters.Add(new SugarParameter(parameterName, item.FieldValue)); + break; default: break; } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Infrastructure/DependencyManagement.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Infrastructure/DependencyManagement.cs index b638424ff..c6ccd3849 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Infrastructure/DependencyManagement.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Infrastructure/DependencyManagement.cs @@ -84,7 +84,7 @@ namespace SqlSugar { var message = ErrorMessage.GetThrowMessage( "You need to refer to Microsoft.Data.Sqlite." + ex.Message, - "你需要引用System.Data.SQLite.dll,如果有版本兼容问题请先删除原有引用"); + "你需要引用Microsoft.Data.Sqlite,如果有版本兼容问题请先删除原有引用"); throw new Exception(message); } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/MySql/SqlBuilder/MySqlExpressionContext.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/MySql/SqlBuilder/MySqlExpressionContext.cs index 64a41861d..879bba742 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/MySql/SqlBuilder/MySqlExpressionContext.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/MySql/SqlBuilder/MySqlExpressionContext.cs @@ -123,5 +123,15 @@ namespace SqlSugar { return " concat("+string.Join(",", strings).Replace("+", "") + ") "; } + public override string IsNull(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + var parameter1 = model.Args[1]; + return string.Format("IFNULL({0},{1})", parameter.MemberName, parameter1.MemberName); + } + public override string GetDate() + { + return "NOW()"; + } } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/DbBind/OracleDbBind.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/DbBind/OracleDbBind.cs index d6d827913..78010f067 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/DbBind/OracleDbBind.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/DbBind/OracleDbBind.cs @@ -9,7 +9,7 @@ namespace SqlSugar public override string GetPropertyTypeName(string dbTypeName) { dbTypeName = dbTypeName.ToLower(); - var propertyTypes = MappingTypes.Where(it => it.Value.ToString().ToLower() == dbTypeName||it.Key.ToLower()== dbTypeName); + var propertyTypes = MappingTypes.Where(it => it.Value.ToString().ToLower() == dbTypeName || it.Key.ToLower() == dbTypeName); if (dbTypeName == "int32") { return "int"; @@ -30,6 +30,10 @@ namespace SqlSugar { return "string"; } + if (dbTypeName == "byte[]") + { + return "byte[]"; + } else if (propertyTypes == null || propertyTypes.Count() == 0) { Check.ThrowNotSupportedException(string.Format(" \"{0}\" Type NotSupported, DbBindProvider.GetPropertyTypeName error.", dbTypeName)); @@ -75,7 +79,7 @@ namespace SqlSugar new KeyValuePair("clob",CSharpDataType.@string), new KeyValuePair("long",CSharpDataType.@string), new KeyValuePair("nclob",CSharpDataType.@string), - new KeyValuePair("rowid",CSharpDataType.@string), + new KeyValuePair("rowid",CSharpDataType.@string), new KeyValuePair("date",CSharpDataType.DateTime), new KeyValuePair("timestamp",CSharpDataType.DateTime), diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/SqlBuilder/OracleExpressionContext.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/SqlBuilder/OracleExpressionContext.cs index 4ed6716a4..a43964aeb 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/SqlBuilder/OracleExpressionContext.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/SqlBuilder/OracleExpressionContext.cs @@ -156,5 +156,22 @@ namespace SqlSugar var parameter = model.Args[0]; return string.Format(" LENGTH({0}) ", parameter.MemberName); } + + public override string IsNull(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + var parameter1 = model.Args[1]; + return string.Format("NVL({0},{1})", parameter.MemberName, parameter1.MemberName); + } + + public override string MergeString(params string[] strings) + { + return string.Join("||", strings).Replace("+", ""); + } + + public override string GetDate() + { + return "sysdate"; + } } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/SqlBuilder/OracleInsertBuilder.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/SqlBuilder/OracleInsertBuilder.cs index d6eb4e8f6..8e9c19b15 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/SqlBuilder/OracleInsertBuilder.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/SqlBuilder/OracleInsertBuilder.cs @@ -109,6 +109,11 @@ namespace SqlSugar { return Convert.ToInt64(value); } + else if (type == UtilConstants.ByteArrayType) + { + string bytesString = "0x" + BitConverter.ToString((byte[])value); + return bytesString; + } else if (type == UtilConstants.BoolType) { return value.ObjToBool() ? "1" : "0"; diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/SqlBuilder/OracleUpdateBuilder.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/SqlBuilder/OracleUpdateBuilder.cs index 242d87074..ecb817b2f 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/SqlBuilder/OracleUpdateBuilder.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/SqlBuilder/OracleUpdateBuilder.cs @@ -10,8 +10,32 @@ namespace SqlSugar { protected override string TomultipleSqlString(List> groupList) { - throw new NotSupportedException("Oracle Waiting for updates updateable(List)"); + StringBuilder sb = new StringBuilder(); + sb.AppendLine("Begin"); + sb.AppendLine(string.Join("\r\n", groupList.Select(t => + { + var updateTable = string.Format("UPDATE {0} SET", base.GetTableNameStringNoWith); + var setValues = string.Join(",", t.Where(s => !s.IsPrimarykey).Select(m => GetOracleUpdateColums(m)).ToArray()); + var pkList = t.Where(s => s.IsPrimarykey).ToList(); + List whereList = new List(); + foreach (var item in pkList) + { + var isFirst = pkList.First() == item; + var whereString = isFirst ? " " : " AND "; + whereString += GetOracleUpdateColums(item); + whereList.Add(whereString); + } + return string.Format("{0} {1} WHERE {2};", updateTable, setValues, string.Join("AND",whereList)); + }).ToArray())); + sb.AppendLine("End;"); + return sb.ToString(); } + + private string GetOracleUpdateColums(DbColumnInfo m) + { + return string.Format("\"{0}\"={1}", m.DbColumnName.ToUpper(), FormatValue(m.Value)); + } + public override object FormatValue(object value) { if (value == null) @@ -34,6 +58,11 @@ namespace SqlSugar { return Convert.ToInt64(value); } + else if (type == UtilConstants.ByteArrayType) + { + string bytesString = "0x" + BitConverter.ToString((byte[])value); + return bytesString; + } else if (type == UtilConstants.BoolType) { return value.ObjToBool() ? "1" : "0"; diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/Updateable/OracleUpdateable.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/Updateable/OracleUpdateable.cs index 1bbf8cf25..60b34b553 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/Updateable/OracleUpdateable.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Oracle/Updateable/OracleUpdateable.cs @@ -11,5 +11,10 @@ namespace SqlSugar { return this.EntityInfo.Columns.Where(it => it.OracleSequenceName.HasValue()).Select(it => it.DbColumnName).ToList(); } + public override int ExecuteCommand() + { + base.ExecuteCommand(); + return base.UpdateObjs.Count(); + } } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteExpressionContext.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteExpressionContext.cs index a925e1deb..f8844eba8 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteExpressionContext.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteExpressionContext.cs @@ -196,5 +196,17 @@ namespace SqlSugar { return string.Join("||", strings).Replace("+",""); } + + public override string IsNull(MethodCallExpressionModel model) + { + var parameter = model.Args[0]; + var parameter1 = model.Args[1]; + return string.Format("IFNULL({0},{1})", parameter.MemberName, parameter1.MemberName); + } + + public override string GetDate() + { + return "DATETIME('now')"; + } } } diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteInsertBuilder.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteInsertBuilder.cs index 3db3f7366..8a9e37272 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteInsertBuilder.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteInsertBuilder.cs @@ -56,6 +56,11 @@ namespace SqlSugar { return Convert.ToInt64(value); } + else if (type == UtilConstants.ByteArrayType) + { + string bytesString = "0x" + BitConverter.ToString((byte[])value); + return bytesString; + } else if (type == UtilConstants.BoolType) { return value.ObjToBool() ? "1" : "0"; diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteUpdateBuilder.cs b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteUpdateBuilder.cs index 029538073..3b3c64cae 100644 --- a/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteUpdateBuilder.cs +++ b/Src/Asp.NetCore2/SqlSeverTest/SqlSugar/Realization/Sqlite/SqlBuilder/SqliteUpdateBuilder.cs @@ -54,6 +54,11 @@ namespace SqlSugar { return Convert.ToInt64(value); } + else if (type == UtilConstants.ByteArrayType) + { + string bytesString = "0x" + BitConverter.ToString((byte[])value); + return bytesString; + } else if (type == UtilConstants.BoolType) { return value.ObjToBool() ? "1" : "0"; diff --git a/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/DataBase/SqlSugar4xTest.sqlite b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/DataBase/SqlSugar4xTest.sqlite index 9701e8a70..a9088fff8 100644 Binary files a/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/DataBase/SqlSugar4xTest.sqlite and b/Src/Asp.NetCore2/SqlSeverTest/SqliteTest/DataBase/SqlSugar4xTest.sqlite differ