lsm/SqlSugar
1
0
Fork 0
mirror of https://gitee.com/dotnetchina/SqlSugar.git synced 2025-04-24 18:04:52 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Code optimization

Browse Source
This commit is contained in:
sunkaixuan 2022-11-26 15:23:30 +08:00
parent 9af6db1c58
commit ac76132f9c
7 changed files with 475 additions and 423 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

357
Src/Asp.Net/SqlSugar/ExpressionsToSql/ResolveItems/BaseResolve.cs
View File

@ -7,357 +7,96 @@ using System.Text;
namespace SqlSugar
{
/// <summary>
///BaseResolve New Expression
/// BaseResolve-Append
/// </summary>
public partial class BaseResolve
{
public string GetNewExpressionValue(Expression item)
private BaseResolve()
{
var newContext = this.Context.GetCopyContextWithMapping();
newContext.SugarContext = this.Context.SugarContext;
newContext.Resolve(item, this.Context.IsJoin ? ResolveExpressType.WhereMultiple : ResolveExpressType.WhereSingle);
this.Context.Index = newContext.Index;
this.Context.ParameterIndex = newContext.ParameterIndex;
if (newContext.Parameters.HasValue())
{
this.Context.Parameters.AddRange(newContext.Parameters);
}
if (this.Context.SingleTableNameSubqueryShortName == "Subqueryable()")
{
this.Context.SingleTableNameSubqueryShortName = newContext.SingleTableNameSubqueryShortName;
}
else if (newContext.SingleTableNameSubqueryShortName!=null&& newContext.Result !=null && newContext.Result.Contains(this.Context.SqlTranslationLeft+ newContext.SingleTableNameSubqueryShortName+ this.Context.SqlTranslationRight))
{
this.Context.SingleTableNameSubqueryShortName = newContext.SingleTableNameSubqueryShortName;
}
return newContext.Result.GetResultString();
}
public BaseResolve(ExpressionParameter parameter)
{
this.Expression = parameter.CurrentExpression;
this.Context = parameter.Context;
this.BaseParameter = parameter;
}
public string GetNewExpressionValue(Expression item, ResolveExpressType type)
public BaseResolve Start()
{
var newContext = this.Context.GetCopyContextWithMapping();
newContext.SugarContext = this.Context.SugarContext;
newContext.Resolve(item, type);
this.Context.Index = newContext.Index;
this.Context.ParameterIndex = newContext.ParameterIndex;
if (newContext.Parameters.HasValue())
Expression expression;
ExpressionParameter parameter;
SetParameter(out expression, out parameter);
if (expression is LambdaExpression)
{
this.Context.Parameters.AddRange(newContext.Parameters);
return new LambdaExpressionResolve(parameter);
}
return newContext.Result.GetResultString();
}
protected void ResolveNewExpressions(ExpressionParameter parameter, Expression item, string asName)
{
if (item is ConstantExpression)
else if (expression is BinaryExpression && expression.NodeType == ExpressionType.Coalesce)
{
ResolveConst(parameter, item, asName);
return new CoalesceResolveItems(parameter);
}
else if ((item is MemberExpression) && ((MemberExpression)item).Expression == null)
else if (expression is BinaryExpression)
{
ResolveMember(parameter, item, asName);
return new BinaryExpressionResolve(parameter);
}
else if ((item is MemberExpression) && ((MemberExpression)item).Expression.NodeType == ExpressionType.Constant)
else if (expression is BlockExpression)
{
ResolveMemberConst(parameter, item, asName);
Check.ThrowNotSupportedException("BlockExpression");
}
else if (item is MemberExpression)
else if (expression is ConditionalExpression)
{
ResolveMemberOther(parameter, item, asName);
return new ConditionalExpressionResolve(parameter);
}
else if (item is UnaryExpression && ((UnaryExpression)item).Operand is MemberExpression)
else if (expression is MethodCallExpression)
{
ResolveUnaryExpMem(parameter, item, asName);
return new MethodCallExpressionResolve(parameter);
}
else if (item is UnaryExpression && ((UnaryExpression)item).Operand is ConstantExpression)
else if (expression is MemberExpression && ((MemberExpression)expression).Expression == null)
{
ResolveUnaryExpConst(parameter, item, asName);
return new MemberNoExpressionResolve(parameter);
}
else if (item is BinaryExpression)
else if (expression is MemberExpression && ((MemberExpression)expression).Expression.NodeType == ExpressionType.Constant)
{
ResolveBinary(item, asName);
return new MemberConstExpressionResolve(parameter);
}
else if (item.Type.IsClass())
else if (expression is MemberExpression && ((MemberExpression)expression).Expression.NodeType == ExpressionType.New)
{
asName = ResolveClass(parameter, item, asName);
return new MemberNewExpressionResolve(parameter);
}
else if (item.Type == UtilConstants.BoolType && item is MethodCallExpression && IsNotCaseExpression(item))
else if (expression is ConstantExpression)
{
ResloveBoolMethod(parameter, item, asName);
return new ConstantExpressionResolve(parameter);
}
else if (item.NodeType == ExpressionType.Not
&& (item as UnaryExpression).Operand is MethodCallExpression
&& ((item as UnaryExpression).Operand as MethodCallExpression).Method.Name.IsIn("IsNullOrEmpty", "IsNullOrWhiteSpace"))
else if (expression is MemberExpression)
{
ResloveNot(parameter, item, asName);
return new MemberExpressionResolve(parameter);
}
else if (item is MethodCallExpression && (item as MethodCallExpression).Method.Name.IsIn("Count", "Any") && !item.ToString().StartsWith("Subqueryable"))
else if (expression is UnaryExpression)
{
ResloveCountAny(parameter, item, asName);
return new UnaryExpressionResolve(parameter);
}
else if (item is MethodCallExpression || item is UnaryExpression || item is ConditionalExpression || item.NodeType == ExpressionType.Coalesce)
else if (expression is MemberInitExpression)
{
ResloveOtherMUC(parameter, item, asName);
return new MemberInitExpressionResolve(parameter);
}
else
else if (expression is NewExpression)
{
Check.ThrowNotSupportedException(item.GetType().Name);
return new NewExpressionResolve(parameter);
}
}
private void ResloveOtherMUC(ExpressionParameter parameter, Expression item, string asName)
{
this.Expression = item;
this.Start();
parameter.Context.Result.Append(this.Context.GetAsString(asName, parameter.CommonTempData.ObjToString()));
}
private void ResloveCountAny(ExpressionParameter parameter, Expression item, string asName)
{
if (this.Context.IsSingle && this.Context.SingleTableNameSubqueryShortName == null)
else if (expression is NewArrayExpression)
{
this.Context.SingleTableNameSubqueryShortName = item.ToString().Split('.').First();
return new NewArrayExpessionResolve(parameter);
}
parameter.Context.Result.Append(this.Context.GetAsString(asName, GetNewExpressionValue(item)));
}
private void ResloveNot(ExpressionParameter parameter, Expression item, string asName)
{
var asValue = GetAsNamePackIfElse(GetNewExpressionValue(item)).ObjToString();
parameter.Context.Result.Append(this.Context.GetAsString(asName, asValue));
}
private void ResloveBoolMethod(ExpressionParameter parameter, Expression item, string asName)
{
this.Expression = item;
this.Start();
var sql = this.Context.DbMehtods.IIF(new MethodCallExpressionModel()
else if (expression is ParameterExpression)
{
Args = new List<MethodCallExpressionArgs>() {
new MethodCallExpressionArgs() {
IsMember=true,
MemberName=parameter.CommonTempData.ObjToString()
},
new MethodCallExpressionArgs() {
IsMember=true,
MemberName=1
},
new MethodCallExpressionArgs() {
IsMember=true,
MemberName=0
}
}
});
parameter.Context.Result.Append(this.Context.GetAsString(asName, sql));
}
private string ResolveClass(ExpressionParameter parameter, Expression item, string asName)
{
var mappingKeys = GetMappingColumns(parameter.CurrentExpression);
var isSameType = mappingKeys.Keys.Count > 0;
CallContextThread<Dictionary<string, string>>.SetData("Exp_Select_Mapping_Key", mappingKeys);
CallContextAsync<Dictionary<string, string>>.SetData("Exp_Select_Mapping_Key", mappingKeys);
this.Expression = item;
if (this.Context.IsJoin && (item is MemberInitExpression || item is NewExpression))
{
List<NewExpressionInfo> newExpressionInfos = new List<NewExpressionInfo>();
if (item is MemberInitExpression)
{
newExpressionInfos = ExpressionTool.GetNewexpressionInfos(item, this.Context, this);
}
else
{
newExpressionInfos = ExpressionTool.GetNewDynamicexpressionInfos(item, this.Context, this);
}
foreach (NewExpressionInfo newExpressionInfo in newExpressionInfos)
{
//var property=item.Type.GetProperties().Where(it => it.Name == newExpressionInfo.l).First();
//asName = GetAsName(item, newExpressionInfo.ShortName, property);
if (newExpressionInfo.Type == nameof(ConstantExpression))
{
parameter.Context.Result.Append(
newExpressionInfo.RightDbName + " AS " +
this.Context.SqlTranslationLeft + asName + "." + newExpressionInfo.LeftNameName + this.Context.SqlTranslationRight
);
}
else
{
parameter.Context.Result.Append(this.Context.GetAsString(
this.Context.SqlTranslationLeft + asName + "." + newExpressionInfo.LeftNameName + this.Context.SqlTranslationRight,
newExpressionInfo.ShortName + "." + newExpressionInfo.RightDbName
));
}
}
return new TypeParameterExpressionReolve(parameter);
}
else if (!this.Context.IsJoin && (item is MemberInitExpression || item is NewExpression))
else if (expression != null && expression.NodeType.IsIn(ExpressionType.NewArrayBounds))
{
List<NewExpressionInfo> newExpressionInfos = new List<NewExpressionInfo>();
if (item is MemberInitExpression)
{
newExpressionInfos = ExpressionTool.GetNewexpressionInfos(item, this.Context, this);
}
else
{
newExpressionInfos = ExpressionTool.GetNewDynamicexpressionInfos(item, this.Context, this);
}
//mappingKeys = new Dictionary<string, string>();
foreach (NewExpressionInfo newExpressionInfo in newExpressionInfos)
{
//var property=item.Type.GetProperties().Where(it => it.Name == newExpressionInfo.l).First();
//asName = GetAsName(item, newExpressionInfo.ShortName, property);
mappingKeys.Add("Single_" + newExpressionInfo.LeftNameName, asName + "." + newExpressionInfo.LeftNameName);
if (newExpressionInfo.Type == nameof(ConstantExpression))
{
CallContextThread<Dictionary<string, string>>.SetData("Exp_Select_Mapping_Key", mappingKeys);
CallContextAsync<Dictionary<string, string>>.SetData("Exp_Select_Mapping_Key", mappingKeys);
parameter.Context.Result.Append($" {newExpressionInfo.RightDbName} AS {this.Context.SqlTranslationLeft}{asName}.{newExpressionInfo.LeftNameName}{this.Context.SqlTranslationRight} ");
}
else
{
CallContextThread<Dictionary<string, string>>.SetData("Exp_Select_Mapping_Key", mappingKeys);
CallContextAsync<Dictionary<string, string>>.SetData("Exp_Select_Mapping_Key", mappingKeys);
parameter.Context.Result.Append(this.Context.GetAsString(
this.Context.SqlTranslationLeft + asName + "." + newExpressionInfo.LeftNameName + this.Context.SqlTranslationRight,
newExpressionInfo.RightDbName
));
}
}
Check.ThrowNotSupportedException("ExpressionType.NewArrayBounds");
}
else if (IsExtSqlFuncObj(item))
{
var value = GetNewExpressionValue(item);
parameter.Context.Result.Append($" {value} AS {asName} ");
}
else
{
asName = GetAsNameResolveAnObject(parameter, item, asName, isSameType);
}
return asName;
}
private void ResolveBinary(Expression item, string asName)
{
if (this.Context.Result.IsLockCurrentParameter == false)
{
var newContext = this.Context.GetCopyContextWithMapping();
var resolveExpressType = this.Context.IsSingle ? ResolveExpressType.WhereSingle : ResolveExpressType.WhereMultiple;
newContext.Resolve(item, resolveExpressType);
this.Context.Index = newContext.Index;
this.Context.ParameterIndex = newContext.ParameterIndex;
if (newContext.Parameters.HasValue())
{
this.Context.Parameters.AddRange(newContext.Parameters);
}
this.Context.Result.Append(this.Context.GetAsString(asName, newContext.Result.GetString()));
this.Context.Result.CurrentParameter = null;
if (this.Context.SingleTableNameSubqueryShortName.IsNullOrEmpty() && newContext.SingleTableNameSubqueryShortName.HasValue())
{
this.Context.SingleTableNameSubqueryShortName = newContext.SingleTableNameSubqueryShortName;
}
}
}
private void ResolveUnaryExpConst(ExpressionParameter parameter, Expression item, string asName)
{
if (this.Context.Result.IsLockCurrentParameter == false)
{
this.Expression = ((UnaryExpression)item).Operand;
this.Start();
string parameterName = this.Context.SqlParameterKeyWord + "constant" + this.Context.ParameterIndex;
this.Context.ParameterIndex++;
parameter.Context.Result.Append(this.Context.GetAsString(asName, parameterName));
this.Context.Parameters.Add(new SugarParameter(parameterName, parameter.CommonTempData));
}
}
private void ResolveUnaryExpMem(ExpressionParameter parameter, Expression item, string asName)
{
if (this.Context.Result.IsLockCurrentParameter == false)
{
var expression = ((UnaryExpression)item).Operand as MemberExpression;
var isDateTimeNow = ((UnaryExpression)item).Operand.ToString() == "DateTime.Now";
if (expression.Expression == null && !isDateTimeNow)
{
this.Context.Result.CurrentParameter = parameter;
this.Context.Result.IsLockCurrentParameter = true;
parameter.IsAppendTempDate();
this.Expression = item;
this.Start();
parameter.IsAppendResult();
this.Context.Result.Append(this.Context.GetAsString(asName, parameter.CommonTempData.ObjToString()));
this.Context.Result.CurrentParameter = null;
}
else if (expression.Expression is ConstantExpression || isDateTimeNow)
{
string parameterName = this.Context.SqlParameterKeyWord + "constant" + this.Context.ParameterIndex;
this.Context.ParameterIndex++;
parameter.Context.Result.Append(this.Context.GetAsString(asName, parameterName));
this.Context.Parameters.Add(new SugarParameter(parameterName, ExpressionTool.GetMemberValue(expression.Member, expression)));
}
else
{
this.Context.Result.CurrentParameter = parameter;
this.Context.Result.IsLockCurrentParameter = true;
parameter.IsAppendTempDate();
this.Expression = expression;
this.Start();
parameter.IsAppendResult();
this.Context.Result.Append(this.Context.GetAsString(asName, parameter.CommonTempData.ObjToString()));
this.Context.Result.CurrentParameter = null;
}
}
}
private void ResolveMemberOther(ExpressionParameter parameter, Expression item, string asName)
{
if (this.Context.Result.IsLockCurrentParameter == false)
{
this.Context.Result.CurrentParameter = parameter;
this.Context.Result.IsLockCurrentParameter = true;
parameter.IsAppendTempDate();
this.Expression = item;
if (IsBoolValue(item))
{
this.Expression = (item as MemberExpression).Expression;
}
this.Start();
parameter.IsAppendResult();
this.Context.Result.Append(this.Context.GetAsString(asName, parameter.CommonTempData.ObjToString()));
this.Context.Result.CurrentParameter = null;
}
}
private void ResolveMemberConst(ExpressionParameter parameter, Expression item, string asName)
{
this.Expression = item;
this.Start();
string parameterName = this.Context.SqlParameterKeyWord + "constant" + this.Context.ParameterIndex;
this.Context.ParameterIndex++;
parameter.Context.Result.Append(this.Context.GetAsString(asName, parameterName));
this.Context.Parameters.Add(new SugarParameter(parameterName, parameter.CommonTempData));
}
private void ResolveMember(ExpressionParameter parameter, Expression item, string asName)
{
var paramterValue = ExpressionTool.GetPropertyValue(item as MemberExpression);
string parameterName = this.Context.SqlParameterKeyWord + "constant" + this.Context.ParameterIndex;
this.Context.ParameterIndex++;
parameter.Context.Result.Append(this.Context.GetAsString(asName, parameterName));
this.Context.Parameters.Add(new SugarParameter(parameterName, paramterValue));
}
private void ResolveConst(ExpressionParameter parameter, Expression item, string asName)
{
this.Expression = item;
this.Start();
string parameterName = this.Context.SqlParameterKeyWord + "constant" + this.Context.ParameterIndex;
this.Context.ParameterIndex++;
parameter.Context.Result.Append(this.Context.GetAsString(asName, parameterName));
this.Context.Parameters.Add(new SugarParameter(parameterName, parameter.CommonTempData));
return null;
}
}
}

22
Src/Asp.Net/SqlSugar/ExpressionsToSql/ResolveItems/BaseResolve_Helper.cs
View File

@ -11,6 +11,7 @@ namespace SqlSugar
/// </summary>
public partial class BaseResolve
{
#region Set Method
protected void SetNavigateResult()
{
if (this.Context != null)
@ -21,6 +22,24 @@ namespace SqlSugar
}
}
}
private void SetParameter(out Expression expression, out ExpressionParameter parameter)
{
Context.Index++;
expression = this.Expression;
parameter = new ExpressionParameter()
{
Context = this.Context,
CurrentExpression = expression,
IsLeft = this.IsLeft,
BaseExpression = this.ExactExpression,
BaseParameter = this.BaseParameter,
Index = Context.Index
};
}
#endregion
#region Get Mehtod
private string GetAsName(Expression item, object shortName, PropertyInfo property)
{
string asName;
@ -163,6 +182,7 @@ namespace SqlSugar
new KeyValuePair<string, string>("End","0")
});
return methodValue;
}
}
#endregion
}
}

268
Src/Asp.Net/SqlSugar/ExpressionsToSql/ResolveItems/BaseResolve_Item.cs Normal file
View File

@ -0,0 +1,268 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
namespace SqlSugar
{
/// <summary>
///BaseResolve New Expression
/// </summary>
public partial class BaseResolve
{
private void ResloveOtherMUC(ExpressionParameter parameter, Expression item, string asName)
{
this.Expression = item;
this.Start();
parameter.Context.Result.Append(this.Context.GetAsString(asName, parameter.CommonTempData.ObjToString()));
}
private void ResloveCountAny(ExpressionParameter parameter, Expression item, string asName)
{
if (this.Context.IsSingle && this.Context.SingleTableNameSubqueryShortName == null)
{
this.Context.SingleTableNameSubqueryShortName = item.ToString().Split('.').First();
}
parameter.Context.Result.Append(this.Context.GetAsString(asName, GetNewExpressionValue(item)));
}
private void ResloveNot(ExpressionParameter parameter, Expression item, string asName)
{
var asValue = GetAsNamePackIfElse(GetNewExpressionValue(item)).ObjToString();
parameter.Context.Result.Append(this.Context.GetAsString(asName, asValue));
}
private void ResloveBoolMethod(ExpressionParameter parameter, Expression item, string asName)
{
this.Expression = item;
this.Start();
var sql = this.Context.DbMehtods.IIF(new MethodCallExpressionModel()
{
Args = new List<MethodCallExpressionArgs>() {
new MethodCallExpressionArgs() {
IsMember=true,
MemberName=parameter.CommonTempData.ObjToString()
},
new MethodCallExpressionArgs() {
IsMember=true,
MemberName=1
},
new MethodCallExpressionArgs() {
IsMember=true,
MemberName=0
}
}
});
parameter.Context.Result.Append(this.Context.GetAsString(asName, sql));
}
private string ResolveClass(ExpressionParameter parameter, Expression item, string asName)
{
var mappingKeys = GetMappingColumns(parameter.CurrentExpression);
var isSameType = mappingKeys.Keys.Count > 0;
CallContextThread<Dictionary<string, string>>.SetData("Exp_Select_Mapping_Key", mappingKeys);
CallContextAsync<Dictionary<string, string>>.SetData("Exp_Select_Mapping_Key", mappingKeys);
this.Expression = item;
if (this.Context.IsJoin && (item is MemberInitExpression || item is NewExpression))
{
List<NewExpressionInfo> newExpressionInfos = new List<NewExpressionInfo>();
if (item is MemberInitExpression)
{
newExpressionInfos = ExpressionTool.GetNewexpressionInfos(item, this.Context, this);
}
else
{
newExpressionInfos = ExpressionTool.GetNewDynamicexpressionInfos(item, this.Context, this);
}
foreach (NewExpressionInfo newExpressionInfo in newExpressionInfos)
{
//var property=item.Type.GetProperties().Where(it => it.Name == newExpressionInfo.l).First();
//asName = GetAsName(item, newExpressionInfo.ShortName, property);
if (newExpressionInfo.Type == nameof(ConstantExpression))
{
parameter.Context.Result.Append(
newExpressionInfo.RightDbName + " AS " +
this.Context.SqlTranslationLeft + asName + "." + newExpressionInfo.LeftNameName + this.Context.SqlTranslationRight
);
}
else
{
parameter.Context.Result.Append(this.Context.GetAsString(
this.Context.SqlTranslationLeft + asName + "." + newExpressionInfo.LeftNameName + this.Context.SqlTranslationRight,
newExpressionInfo.ShortName + "." + newExpressionInfo.RightDbName
));
}
}
}
else if (!this.Context.IsJoin && (item is MemberInitExpression || item is NewExpression))
{
List<NewExpressionInfo> newExpressionInfos = new List<NewExpressionInfo>();
if (item is MemberInitExpression)
{
newExpressionInfos = ExpressionTool.GetNewexpressionInfos(item, this.Context, this);
}
else
{
newExpressionInfos = ExpressionTool.GetNewDynamicexpressionInfos(item, this.Context, this);
}
//mappingKeys = new Dictionary<string, string>();
foreach (NewExpressionInfo newExpressionInfo in newExpressionInfos)
{
//var property=item.Type.GetProperties().Where(it => it.Name == newExpressionInfo.l).First();
//asName = GetAsName(item, newExpressionInfo.ShortName, property);
mappingKeys.Add("Single_" + newExpressionInfo.LeftNameName, asName + "." + newExpressionInfo.LeftNameName);
if (newExpressionInfo.Type == nameof(ConstantExpression))
{
CallContextThread<Dictionary<string, string>>.SetData("Exp_Select_Mapping_Key", mappingKeys);
CallContextAsync<Dictionary<string, string>>.SetData("Exp_Select_Mapping_Key", mappingKeys);
parameter.Context.Result.Append($" {newExpressionInfo.RightDbName} AS {this.Context.SqlTranslationLeft}{asName}.{newExpressionInfo.LeftNameName}{this.Context.SqlTranslationRight} ");
}
else
{
CallContextThread<Dictionary<string, string>>.SetData("Exp_Select_Mapping_Key", mappingKeys);
CallContextAsync<Dictionary<string, string>>.SetData("Exp_Select_Mapping_Key", mappingKeys);
parameter.Context.Result.Append(this.Context.GetAsString(
this.Context.SqlTranslationLeft + asName + "." + newExpressionInfo.LeftNameName + this.Context.SqlTranslationRight,
newExpressionInfo.RightDbName
));
}
}
}
else if (IsExtSqlFuncObj(item))
{
var value = GetNewExpressionValue(item);
parameter.Context.Result.Append($" {value} AS {asName} ");
}
else
{
asName = GetAsNameResolveAnObject(parameter, item, asName, isSameType);
}
return asName;
}
private void ResolveBinary(Expression item, string asName)
{
if (this.Context.Result.IsLockCurrentParameter == false)
{
var newContext = this.Context.GetCopyContextWithMapping();
var resolveExpressType = this.Context.IsSingle ? ResolveExpressType.WhereSingle : ResolveExpressType.WhereMultiple;
newContext.Resolve(item, resolveExpressType);
this.Context.Index = newContext.Index;
this.Context.ParameterIndex = newContext.ParameterIndex;
if (newContext.Parameters.HasValue())
{
this.Context.Parameters.AddRange(newContext.Parameters);
}
this.Context.Result.Append(this.Context.GetAsString(asName, newContext.Result.GetString()));
this.Context.Result.CurrentParameter = null;
if (this.Context.SingleTableNameSubqueryShortName.IsNullOrEmpty() && newContext.SingleTableNameSubqueryShortName.HasValue())
{
this.Context.SingleTableNameSubqueryShortName = newContext.SingleTableNameSubqueryShortName;
}
}
}
private void ResolveUnaryExpConst(ExpressionParameter parameter, Expression item, string asName)
{
if (this.Context.Result.IsLockCurrentParameter == false)
{
this.Expression = ((UnaryExpression)item).Operand;
this.Start();
string parameterName = this.Context.SqlParameterKeyWord + "constant" + this.Context.ParameterIndex;
this.Context.ParameterIndex++;
parameter.Context.Result.Append(this.Context.GetAsString(asName, parameterName));
this.Context.Parameters.Add(new SugarParameter(parameterName, parameter.CommonTempData));
}
}
private void ResolveUnaryExpMem(ExpressionParameter parameter, Expression item, string asName)
{
if (this.Context.Result.IsLockCurrentParameter == false)
{
var expression = ((UnaryExpression)item).Operand as MemberExpression;
var isDateTimeNow = ((UnaryExpression)item).Operand.ToString() == "DateTime.Now";
if (expression.Expression == null && !isDateTimeNow)
{
this.Context.Result.CurrentParameter = parameter;
this.Context.Result.IsLockCurrentParameter = true;
parameter.IsAppendTempDate();
this.Expression = item;
this.Start();
parameter.IsAppendResult();
this.Context.Result.Append(this.Context.GetAsString(asName, parameter.CommonTempData.ObjToString()));
this.Context.Result.CurrentParameter = null;
}
else if (expression.Expression is ConstantExpression || isDateTimeNow)
{
string parameterName = this.Context.SqlParameterKeyWord + "constant" + this.Context.ParameterIndex;
this.Context.ParameterIndex++;
parameter.Context.Result.Append(this.Context.GetAsString(asName, parameterName));
this.Context.Parameters.Add(new SugarParameter(parameterName, ExpressionTool.GetMemberValue(expression.Member, expression)));
}
else
{
this.Context.Result.CurrentParameter = parameter;
this.Context.Result.IsLockCurrentParameter = true;
parameter.IsAppendTempDate();
this.Expression = expression;
this.Start();
parameter.IsAppendResult();
this.Context.Result.Append(this.Context.GetAsString(asName, parameter.CommonTempData.ObjToString()));
this.Context.Result.CurrentParameter = null;
}
}
}
private void ResolveMemberOther(ExpressionParameter parameter, Expression item, string asName)
{
if (this.Context.Result.IsLockCurrentParameter == false)
{
this.Context.Result.CurrentParameter = parameter;
this.Context.Result.IsLockCurrentParameter = true;
parameter.IsAppendTempDate();
this.Expression = item;
if (IsBoolValue(item))
{
this.Expression = (item as MemberExpression).Expression;
}
this.Start();
parameter.IsAppendResult();
this.Context.Result.Append(this.Context.GetAsString(asName, parameter.CommonTempData.ObjToString()));
this.Context.Result.CurrentParameter = null;
}
}
private void ResolveMemberConst(ExpressionParameter parameter, Expression item, string asName)
{
this.Expression = item;
this.Start();
string parameterName = this.Context.SqlParameterKeyWord + "constant" + this.Context.ParameterIndex;
this.Context.ParameterIndex++;
parameter.Context.Result.Append(this.Context.GetAsString(asName, parameterName));
this.Context.Parameters.Add(new SugarParameter(parameterName, parameter.CommonTempData));
}
private void ResolveMember(ExpressionParameter parameter, Expression item, string asName)
{
var paramterValue = ExpressionTool.GetPropertyValue(item as MemberExpression);
string parameterName = this.Context.SqlParameterKeyWord + "constant" + this.Context.ParameterIndex;
this.Context.ParameterIndex++;
parameter.Context.Result.Append(this.Context.GetAsString(asName, parameterName));
this.Context.Parameters.Add(new SugarParameter(parameterName, paramterValue));
}
private void ResolveConst(ExpressionParameter parameter, Expression item, string asName)
{
this.Expression = item;
this.Start();
string parameterName = this.Context.SqlParameterKeyWord + "constant" + this.Context.ParameterIndex;
this.Context.ParameterIndex++;
parameter.Context.Result.Append(this.Context.GetAsString(asName, parameterName));
this.Context.Parameters.Add(new SugarParameter(parameterName, parameter.CommonTempData));
}
}
}

109
Src/Asp.Net/SqlSugar/ExpressionsToSql/ResolveItems/BaseResolve_NewExp.cs Normal file
View File

@ -0,0 +1,109 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
namespace SqlSugar
{
/// <summary>
///BaseResolve New Expression
/// </summary>
public partial class BaseResolve
{
public string GetNewExpressionValue(Expression item)
{
var newContext = this.Context.GetCopyContextWithMapping();
newContext.SugarContext = this.Context.SugarContext;
newContext.Resolve(item, this.Context.IsJoin ? ResolveExpressType.WhereMultiple : ResolveExpressType.WhereSingle);
this.Context.Index = newContext.Index;
this.Context.ParameterIndex = newContext.ParameterIndex;
if (newContext.Parameters.HasValue())
{
this.Context.Parameters.AddRange(newContext.Parameters);
}
if (this.Context.SingleTableNameSubqueryShortName == "Subqueryable()")
{
this.Context.SingleTableNameSubqueryShortName = newContext.SingleTableNameSubqueryShortName;
}
else if (newContext.SingleTableNameSubqueryShortName!=null&& newContext.Result !=null && newContext.Result.Contains(this.Context.SqlTranslationLeft+ newContext.SingleTableNameSubqueryShortName+ this.Context.SqlTranslationRight))
{
this.Context.SingleTableNameSubqueryShortName = newContext.SingleTableNameSubqueryShortName;
}
return newContext.Result.GetResultString();
}
public string GetNewExpressionValue(Expression item, ResolveExpressType type)
{
var newContext = this.Context.GetCopyContextWithMapping();
newContext.SugarContext = this.Context.SugarContext;
newContext.Resolve(item, type);
this.Context.Index = newContext.Index;
this.Context.ParameterIndex = newContext.ParameterIndex;
if (newContext.Parameters.HasValue())
{
this.Context.Parameters.AddRange(newContext.Parameters);
}
return newContext.Result.GetResultString();
}
protected void ResolveNewExpressions(ExpressionParameter parameter, Expression item, string asName)
{
if (item is ConstantExpression)
{
ResolveConst(parameter, item, asName);
}
else if ((item is MemberExpression) && ((MemberExpression)item).Expression == null)
{
ResolveMember(parameter, item, asName);
}
else if ((item is MemberExpression) && ((MemberExpression)item).Expression.NodeType == ExpressionType.Constant)
{
ResolveMemberConst(parameter, item, asName);
}
else if (item is MemberExpression)
{
ResolveMemberOther(parameter, item, asName);
}
else if (item is UnaryExpression && ((UnaryExpression)item).Operand is MemberExpression)
{
ResolveUnaryExpMem(parameter, item, asName);
}
else if (item is UnaryExpression && ((UnaryExpression)item).Operand is ConstantExpression)
{
ResolveUnaryExpConst(parameter, item, asName);
}
else if (item is BinaryExpression)
{
ResolveBinary(item, asName);
}
else if (item.Type.IsClass())
{
asName = ResolveClass(parameter, item, asName);
}
else if (item.Type == UtilConstants.BoolType && item is MethodCallExpression && IsNotCaseExpression(item))
{
ResloveBoolMethod(parameter, item, asName);
}
else if (item.NodeType == ExpressionType.Not
&& (item as UnaryExpression).Operand is MethodCallExpression
&& ((item as UnaryExpression).Operand as MethodCallExpression).Method.Name.IsIn("IsNullOrEmpty", "IsNullOrWhiteSpace"))
{
ResloveNot(parameter, item, asName);
}
else if (item is MethodCallExpression && (item as MethodCallExpression).Method.Name.IsIn("Count", "Any") && !item.ToString().StartsWith("Subqueryable"))
{
ResloveCountAny(parameter, item, asName);
}
else if (item is MethodCallExpression || item is UnaryExpression || item is ConditionalExpression || item.NodeType == ExpressionType.Coalesce)
{
ResloveOtherMUC(parameter, item, asName);
}
else
{
Check.ThrowNotSupportedException(item.GetType().Name);
}
}
}
}

96
Src/Asp.Net/SqlSugar/ExpressionsToSql/ResolveItems/BaseResolve_Property.cs
View File

@ -16,102 +16,6 @@ namespace SqlSugar
public int ContentIndex { get { return this.Context.Index; } }
public int Index { get; set; }
public ExpressionParameter BaseParameter { get; set; }
private BaseResolve()
{
}
public BaseResolve(ExpressionParameter parameter)
{
this.Expression = parameter.CurrentExpression;
this.Context = parameter.Context;
this.BaseParameter = parameter;
}
public BaseResolve Start()
{
Context.Index++;
Expression expression = this.Expression;
ExpressionParameter parameter = new ExpressionParameter()
{
Context = this.Context,
CurrentExpression = expression,
IsLeft = this.IsLeft,
BaseExpression = this.ExactExpression,
BaseParameter = this.BaseParameter,
Index = Context.Index
};
if (expression is LambdaExpression)
{
return new LambdaExpressionResolve(parameter);
}
else if (expression is BinaryExpression && expression.NodeType == ExpressionType.Coalesce)
{
return new CoalesceResolveItems(parameter);
}
else if (expression is BinaryExpression)
{
return new BinaryExpressionResolve(parameter);
}
else if (expression is BlockExpression)
{
Check.ThrowNotSupportedException("BlockExpression");
}
else if (expression is ConditionalExpression)
{
return new ConditionalExpressionResolve(parameter);
}
else if (expression is MethodCallExpression)
{
return new MethodCallExpressionResolve(parameter);
}
else if (expression is MemberExpression && ((MemberExpression)expression).Expression == null)
{
return new MemberNoExpressionResolve(parameter);
}
else if (expression is MemberExpression && ((MemberExpression)expression).Expression.NodeType == ExpressionType.Constant)
{
return new MemberConstExpressionResolve(parameter);
}
else if (expression is MemberExpression && ((MemberExpression)expression).Expression.NodeType == ExpressionType.New)
{
return new MemberNewExpressionResolve(parameter);
}
else if (expression is ConstantExpression)
{
return new ConstantExpressionResolve(parameter);
}
else if (expression is MemberExpression)
{
return new MemberExpressionResolve(parameter);
}
else if (expression is UnaryExpression)
{
return new UnaryExpressionResolve(parameter);
}
else if (expression is MemberInitExpression)
{
return new MemberInitExpressionResolve(parameter);
}
else if (expression is NewExpression)
{
return new NewExpressionResolve(parameter);
}
else if (expression is NewArrayExpression)
{
return new NewArrayExpessionResolve(parameter);
}
else if (expression is ParameterExpression)
{
return new TypeParameterExpressionReolve(parameter);
}
else if (expression != null && expression.NodeType.IsIn(ExpressionType.NewArrayBounds))
{
Check.ThrowNotSupportedException("ExpressionType.NewArrayBounds");
}
return null;
}
#endregion
#region Dictionary

42
Src/Asp.Net/SqlSugar/ExpressionsToSql/ResolveItems/ConstantExpressionResolve.cs
View File

@ -12,22 +12,9 @@ namespace SqlSugar
{
var expression = base.Expression as ConstantExpression;
var isLeft = parameter.IsLeft;
object value = ExpressionTool.GetValue(expression.Value,this.Context);
if (this.Context.TableEnumIsString == true
&& value != null
&& value.IsInt()
&& base.BaseParameter?.OppsiteExpression != null)
{
if (base.BaseParameter?.OppsiteExpression is UnaryExpression)
{
var oppsiteExpression = base.BaseParameter?.OppsiteExpression as UnaryExpression;
var oppsiteValue = oppsiteExpression.Operand;
if (oppsiteValue.Type.IsEnum())
{
value = UtilMethods.ChangeType2(value, oppsiteValue.Type).ToString();
}
}
}
object value = ExpressionTool.GetValue(expression.Value, this.Context);
if (IsEnumString(value))
value = ConvertEnum(value);
var baseParameter = parameter.BaseParameter;
baseParameter.ChildExpression = expression;
var isSetTempData = baseParameter.CommonTempData.HasValue() && baseParameter.CommonTempData.Equals(CommonTempDataType.Result);
@ -81,5 +68,28 @@ namespace SqlSugar
break;
}
}
private object ConvertEnum(object value)
{
if (base.BaseParameter?.OppsiteExpression is UnaryExpression)
{
var oppsiteExpression = base.BaseParameter?.OppsiteExpression as UnaryExpression;
var oppsiteValue = oppsiteExpression.Operand;
if (oppsiteValue.Type.IsEnum())
{
value = UtilMethods.ChangeType2(value, oppsiteValue.Type).ToString();
}
}
return value;
}
private bool IsEnumString(object value)
{
return this.Context.TableEnumIsString == true
&& value != null
&& value.IsInt()
&& base.BaseParameter?.OppsiteExpression != null;
}
}
}

4
Src/Asp.Net/SqlSugar/SqlSugar.csproj
View File

@ -139,6 +139,8 @@
<Compile Include="ExpressionsToSql\ResolveItems\BaseResolve_Helper.cs" />
<Compile Include="ExpressionsToSql\ResolveItems\BaseResolve_Validate.cs" />
<Compile Include="ExpressionsToSql\ResolveItems\BaseResolve_Property.cs" />
<Compile Include="ExpressionsToSql\ResolveItems\BaseResolve.cs" />
<Compile Include="ExpressionsToSql\ResolveItems\BaseResolve_Item.cs" />
<Compile Include="ExpressionsToSql\ResolveItems\MethodCallExpressionResolve_Helper.cs" />
<Compile Include="ExpressionsToSql\ResolveItems\MethodCallExpressionResolve_BaseDateFomat.cs" />
<Compile Include="ExpressionsToSql\Subquery\Items\SubDistinctCount.cs" />
@ -517,7 +519,7 @@
<Compile Include="Enum\OrderByType.cs" />
<Compile Include="ExpressionsToSql\Common\ResolveExpressType.cs" />
<Compile Include="ExpressionsToSql\Common\ExpressionConst.cs" />
<Compile Include="ExpressionsToSql\ResolveItems\BaseResolve.cs" />
<Compile Include="ExpressionsToSql\ResolveItems\BaseResolve_NewExp.cs" />
<Compile Include="ExpressionsToSql\ResolveItems\BinaryExpressionResolve.cs" />
<Compile Include="ExpressionsToSql\ResolveItems\BlockExpressionResolve.cs" />
<Compile Include="ExpressionsToSql\ResolveItems\ConditionalExpressionResolve.cs" />