lsm/SqlSugar
1
0
Fork 0
mirror of https://gitee.com/dotnetchina/SqlSugar.git synced 2025-08-24 16:18:47 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
59948f8870
SqlSugar/Src/Asp.Net/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs

949 lines
48 KiB
C#
Raw Normal View History

StringIsNullOrEmpty
2017-01-30 15:10:54 +08:00
using SqlSugar;
using System;
Add SqlFunc.ContainsArrayUseSqlParameters
2019-06-09 20:51:57 +08:00
using System.Collections;
Ok
2017-01-07 21:54:51 +08:00
using System.Collections.Generic;
Support native methods
2017-06-14 00:20:41 +08:00
using System.Collections.ObjectModel;
Ok
2017-01-07 21:54:51 +08:00
using System.Linq;
using System.Linq.Expressions;
using System.Text;
Update exp to sql
2019-05-15 18:11:44 +08:00
using System.Text.RegularExpressions;
Ok
2017-01-07 21:54:51 +08:00
namespace SqlSugar
{
StringIsNullOrEmpty
2017-01-30 15:10:54 +08:00
public class MethodCallExpressionResolve : BaseResolve
Ok
2017-01-07 21:54:51 +08:00
{
Update exp to sql
2019-02-09 20:53:44 +08:00
int contextIndex = 0;
-
2017-01-07 23:56:55 +08:00
public MethodCallExpressionResolve(ExpressionParameter parameter) : base(parameter)
Ok
2017-01-07 21:54:51 +08:00
{
Update exp to sql
2019-02-09 20:53:44 +08:00
contextIndex = this.Context.Index;
StringIsNullOrEmpty
2017-01-30 15:10:54 +08:00
var express = base.Expression as MethodCallExpression;
Exp to sql support conditional ? true : false
2019-02-09 18:49:32 +08:00
if (express == null) return;
-
2017-01-31 20:13:22 +08:00
var isLeft = parameter.IsLeft;
-
2017-06-14 01:00:16 +08:00
string methodName = express.Method.Name;
Support custom SqlFunc Method
2017-11-17 14:08:25 +08:00
var isValidNativeMethod = IsValidNativeMethod(express, methodName);
Support System.Date.addXXX
2017-07-16 04:35:42 +08:00
List<MethodCallExpressionArgs> appendArgs = null;
if (MethodTimeMapping.ContainsKey(methodName))
{
appendArgs = new List<MethodCallExpressionArgs>();
var dateType = MethodTimeMapping[methodName];
string paramterName = this.Context.SqlParameterKeyWord + ExpressionConst.Const + this.Context.ParameterIndex;
Optimization analysis
2017-08-13 21:34:29 +08:00
appendArgs.Add(new MethodCallExpressionArgs() { IsMember = false, MemberName = paramterName, MemberValue = dateType });
Support System.Date.addXXX
2017-07-16 04:35:42 +08:00
this.Context.Parameters.Add(new SugarParameter(paramterName, dateType.ToString()));
this.Context.ParameterIndex++;
methodName = "DateAdd";
isValidNativeMethod = true;
}
else if (methodName == "get_Item")
Expression Support Guid.New
2017-07-12 00:15:14 +08:00
{
string paramterName = this.Context.SqlParameterKeyWord + ExpressionConst.Const + this.Context.ParameterIndex;
Expression Dictionary BUG
2017-06-27 16:25:36 +08:00
this.Context.Parameters.Add(new SugarParameter(paramterName, ExpressionTool.DynamicInvoke(express)));
Expression Support Guid.New
2017-07-12 00:15:14 +08:00
this.Context.Result.Append(string.Format(" {0} ", paramterName));
Expression Dictionary BUG
2017-06-27 16:25:36 +08:00
this.Context.ParameterIndex++;
return;
}
Support System.Date.addXXX
2017-07-16 04:35:42 +08:00
else if (methodName == "NewGuid")
{
Expression Support Guid.New
2017-07-12 00:15:14 +08:00
this.Context.Result.Append(this.Context.DbMehtods.GuidNew());
return;
}
Add a configuration table query
2021-04-24 03:20:01 +08:00
else if (methodName == "GetConfigValue")
{
GetConfigValue(express,parameter);
return;
}
Subquery
2017-09-16 16:01:26 +08:00
else if (IsSubMethod(express, methodName))
{
-
2017-09-16 21:56:53 +08:00
//Check.Exception(!(parameter.BaseExpression is BinaryExpression), "Current expressions are not supported");
SubResolve subResolve = new SubResolve(express, this.Context, parameter.OppsiteExpression);
Subquery
2017-09-16 16:01:26 +08:00
var appendSql = subResolve.GetSql();
Update exp to sql
2019-05-15 18:11:44 +08:00
if (this.Context.ResolveType.IsIn(ResolveExpressType.SelectMultiple, ResolveExpressType.SelectSingle) || (parameter.BaseParameter != null && parameter.BaseParameter.CommonTempData != null && parameter.BaseParameter.CommonTempData.Equals(CommonTempDataType.Result)))
-
2017-09-16 21:56:53 +08:00
{
parameter.BaseParameter.CommonTempData = appendSql;
}
else
{
base.AppendValue(parameter, isLeft, appendSql);
}
Subquery
2017-09-16 16:01:26 +08:00
return;
}
Support custom SqlFunc Method
2017-11-17 14:08:25 +08:00
else if (IsIfElse(express, methodName))
{
4.6.0.1
2017-11-10 12:35:41 +08:00
CaseWhenResolve caseResole = new CaseWhenResolve(express, this.Context, parameter.OppsiteExpression);
var appendSql = caseResole.GetSql();
Update exp to sql
2019-05-15 18:11:44 +08:00
var isRoot = contextIndex == 2 && parameter.BaseExpression == null;
if (isRoot || (parameter.BaseExpression != null && ExpressionTool.IsLogicOperator(parameter.BaseExpression)))
{
appendSql = appendSql + "=1 ";
Update exp to sql
2019-02-09 21:05:48 +08:00
}
Update exp to sql
2019-05-15 18:11:44 +08:00
if (this.Context.ResolveType.IsIn(ResolveExpressType.SelectMultiple, ResolveExpressType.SelectSingle, ResolveExpressType.Update))
4.6.0.1
2017-11-10 12:35:41 +08:00
{
parameter.BaseParameter.CommonTempData = appendSql;
}
else
{
base.AppendValue(parameter, isLeft, appendSql);
}
Rich query
2017-11-09 10:26:03 +08:00
return;
}
-
2017-09-16 21:56:53 +08:00
if (IsContainsArray(express, methodName, isValidNativeMethod))
Support System.Date.addXXX
2017-07-16 04:35:42 +08:00
{
-
2017-06-14 01:08:12 +08:00
methodName = "ContainsArray";
isValidNativeMethod = true;
}
Support native methods
2017-06-14 00:20:41 +08:00
if (isValidNativeMethod)
{
Optimization analysis
2017-08-13 21:34:29 +08:00
NativeExtensionMethod(parameter, express, isLeft, MethodMapping[methodName], appendArgs);
Support native methods
2017-06-14 00:20:41 +08:00
}
else
{
SqlFuncMethod(parameter, express, isLeft);
}
}
Add a configuration table query
2021-04-24 03:20:01 +08:00
private void GetConfigValue(MethodCallExpression express,ExpressionParameter parameter)
{
var exp = express.Arguments[0];
var name =Regex.Match(express.Method.ToString(), @"GetConfigValue\[(.+)\]").Groups[1].Value;
string code = null;
if (express.Arguments.Count > 1)
{
code=ExpressionTool.GetExpressionValue(express.Arguments[1])+"";
}
code optimization
2021-07-04 14:36:57 +08:00
var entityDb= SqlFuncExtendsion.TableInfos.FirstOrDefault(y => y.Type.Name == name&&y.Code== code);
Check.Exception(entityDb == null,string.Format( "GetConfigValue no configuration Entity={0} UniqueCode={1}",name,code));
var entity = new ConfigTableInfo()
{
Code = entityDb.Code,
TableName = entityDb.TableName,
Key = entityDb.Key,
code optimization
2021-07-04 15:05:19 +08:00
Parameter = new List<SugarParameter>(),
code optimization
2021-07-04 14:36:57 +08:00
Type = entityDb.Type,
Value = entityDb.Value,
Where = entityDb.Where
};
code optimization
2021-07-04 15:05:19 +08:00
if (entityDb.Parameter != null && entityDb.Parameter.Any())
{
foreach (var item in entityDb.Parameter)
{
entity.Parameter.Add(new SugarParameter("", null) {
DbType=item.DbType,
Direction=item.Direction,
IsArray=item.IsArray,
IsJson=item.IsJson,
IsNullable=item.IsNullable,
IsRefCursor=item.IsRefCursor,
ParameterName=item.ParameterName,
Size=item.Size,
SourceColumn=item.SourceColumn,
SourceColumnNullMapping=item.SourceColumnNullMapping,
SourceVersion=item.SourceVersion,
TempDate=item.TempDate,
TypeName=item.TypeName,
Value=item.Value,
_Size=item._Size
});
}
}
Add a configuration table query
2021-04-24 03:20:01 +08:00
string sql = " (SELECT {0} FROM {1} WHERE {2}={3}";
if (ExpressionTool.IsUnConvertExpress(exp))
{
exp = (exp as UnaryExpression).Operand;
}
var member = exp as MemberExpression;
var it = member.Expression;
var type = it.Type;
var properyName =member.Member.Name;
var eqName = string.Format("{0}.{1}",this.Context.GetTranslationColumnName(it.ToString()), this.Context.GetDbColumnName(type.Name,properyName));
if (this.Context.IsSingle)
{
this.Context.SingleTableNameSubqueryShortName = it.ToString();
}
sql = string.Format(sql,entity.Value,this.Context.GetTranslationColumnName(entity.TableName),entity.Key, eqName);
if (entity.Parameter != null)
{
foreach (var item in entity.Parameter)
{
var oldName = item.ParameterName;
ConfigQuery BUG
2021-06-29 17:42:53 +08:00
item.ParameterName = Regex.Split(oldName,"_con_").First() + "_con_" + this.Context.ParameterIndex;
Add a configuration table query
2021-04-24 03:20:01 +08:00
entity.Where = entity.Where.Replace(oldName, item.ParameterName);
}
this.Context.ParameterIndex++;
this.Context.Parameters.AddRange(entity.Parameter);
}
if (entity.Where.HasValue())
{
sql += " AND " + entity.Where;
}
sql += " )";
if (this.Context.ResolveType.IsIn(ResolveExpressType.SelectMultiple, ResolveExpressType.SelectSingle, ResolveExpressType.Update))
{
parameter.BaseParameter.CommonTempData = sql;
}
else
{
AppendMember(parameter, parameter.IsLeft, sql);
}
}
Update exp to sql
2019-05-15 18:11:44 +08:00
private bool IsValidNativeMethod(MethodCallExpression express, string methodName)
Support custom SqlFunc Method
2017-11-17 14:08:25 +08:00
{
return MethodMapping.ContainsKey(methodName) && express.Method.DeclaringType.Namespace == ("System");
}
private bool IsExtMethod(string methodName)
{
if (this.Context.SqlFuncServices == null) return false;
return this.Context.SqlFuncServices.Select(it => it.UniqueMethodName).Contains(methodName);
}
Rich query
2017-11-09 10:26:03 +08:00
private bool IsIfElse(MethodCallExpression express, string methodName)
{
Update exp to sql
2019-05-15 18:11:44 +08:00
if (methodName == "End" && express.Object.Type == typeof(CaseWhen))
Rich query
2017-11-09 10:26:03 +08:00
return true;
else
return false;
}
Exp to sql support conditional ? true : false
2019-02-09 18:49:32 +08:00
protected void SqlFuncMethod(ExpressionParameter parameter, MethodCallExpression express, bool? isLeft)
Support native methods
2017-06-14 00:20:41 +08:00
{
-
2017-11-28 13:06:57 +08:00
if (!CheckMethod(express))
{
CusMethod(parameter, express, isLeft);
-
2017-11-28 12:45:43 +08:00
}
-
2017-11-28 13:06:57 +08:00
else
StringIsNullOrEmpty
2017-01-30 15:10:54 +08:00
{
-
2017-11-28 13:06:57 +08:00
var method = express.Method;
string name = method.Name;
var args = express.Arguments.Cast<Expression>().ToList();
MethodCallExpressionModel model = new MethodCallExpressionModel();
model.Args = new List<MethodCallExpressionArgs>();
switch (this.Context.ResolveType)
{
case ResolveExpressType.WhereSingle:
case ResolveExpressType.WhereMultiple:
Check.Exception(name == "GetSelfAndAutoFill", "SqlFunc.GetSelfAndAutoFill can only be used in Select.");
Where(parameter, isLeft, name, args, model);
break;
case ResolveExpressType.SelectSingle:
case ResolveExpressType.SelectMultiple:
case ResolveExpressType.Update:
Select(parameter, isLeft, name, args, model);
break;
case ResolveExpressType.FieldSingle:
case ResolveExpressType.FieldMultiple:
Field(parameter, isLeft, name, args, model);
break;
default:
break;
}
StringIsNullOrEmpty
2017-01-30 15:10:54 +08:00
}
}
-
2017-11-28 13:06:57 +08:00
private void CusMethod(ExpressionParameter parameter, MethodCallExpression express, bool? isLeft)
{
try
{
var constValue = ExpressionTool.DynamicInvoke(express);
Support on to many where( it.xx.count()>0)
2021-01-17 02:35:33 +08:00
if (constValue is MapperSql)
{
constValue = (constValue as MapperSql).Sql;
base.AppendValue(parameter, isLeft, constValue);
return;
}
-
2017-11-28 13:06:57 +08:00
parameter.BaseParameter.CommonTempData = constValue;
var parameterName = base.AppendParameter(constValue);
if (parameter.BaseParameter.CommonTempData != null && parameter.BaseParameter.CommonTempData.Equals(CommonTempDataType.Result))
{
this.Context.Result.Append(parameterName);
}
else
{
base.AppendValue(parameter, isLeft, parameterName);
}
}
catch
{
Check.Exception(true, string.Format(ErrorMessage.MethodError, express.Method.Name));
}
}
Support System.Date.addXXX
2017-07-16 04:35:42 +08:00
private void NativeExtensionMethod(ExpressionParameter parameter, MethodCallExpression express, bool? isLeft, string name, List<MethodCallExpressionArgs> appendArgs = null)
Support native methods
2017-06-14 00:20:41 +08:00
{
var method = express.Method;
var args = express.Arguments.Cast<Expression>().ToList();
MethodCallExpressionModel model = new MethodCallExpressionModel();
Update exp to sql
2019-04-28 14:39:24 +08:00
model.Name = name;
Support native methods
2017-06-14 00:20:41 +08:00
model.Args = new List<MethodCallExpressionArgs>();
switch (this.Context.ResolveType)
{
case ResolveExpressType.WhereSingle:
case ResolveExpressType.WhereMultiple:
if (express.Object != null)
-
2017-06-14 01:00:16 +08:00
args.Insert(0, express.Object);
Support System.Date.addXXX
2017-07-16 04:35:42 +08:00
Where(parameter, isLeft, name, args, model, appendArgs);
Support native methods
2017-06-14 00:20:41 +08:00
break;
case ResolveExpressType.SelectSingle:
case ResolveExpressType.SelectMultiple:
case ResolveExpressType.Update:
if (express.Object != null)
args.Insert(0, express.Object);
Support System.Date.addXXX
2017-07-16 04:35:42 +08:00
Select(parameter, isLeft, name, args, model, appendArgs);
Support native methods
2017-06-14 00:20:41 +08:00
break;
case ResolveExpressType.FieldSingle:
case ResolveExpressType.FieldMultiple:
default:
break;
}
}
Exp to sql support conditional ? true : false
2019-02-09 18:49:32 +08:00
protected void Field(ExpressionParameter parameter, bool? isLeft, string name, IEnumerable<Expression> args, MethodCallExpressionModel model, List<MethodCallExpressionArgs> appendArgs = null)
-
2017-08-14 01:01:23 +08:00
{
if (this.Context.ResolveType == ResolveExpressType.FieldSingle)
{
this.Context.ResolveType = ResolveExpressType.WhereSingle;
}
Subquery
2017-09-16 16:01:26 +08:00
else
{
-
2017-08-14 01:01:23 +08:00
this.Context.ResolveType = ResolveExpressType.WhereMultiple;
}
Where(parameter, isLeft, name, args, model);
}
Exp to sql support conditional ? true : false
2019-02-09 18:49:32 +08:00
protected void Select(ExpressionParameter parameter, bool? isLeft, string name, IEnumerable<Expression> args, MethodCallExpressionModel model, List<MethodCallExpressionArgs> appendArgs = null)
-
2017-04-30 16:11:51 +08:00
{
rename
2021-04-24 12:36:39 +08:00
if (name.IsIn("GetSelfAndAutoFill","SelectAll"))
-
2017-04-30 16:11:51 +08:00
{
Add SqlFunc.GetSelfAndAutoFill
2017-07-17 12:56:21 +08:00
var memberValue = (args.First() as MemberExpression).Expression.ToString();
Optimization analysis
2017-08-13 21:34:29 +08:00
model.Args.Add(new MethodCallExpressionArgs() { MemberValue = memberValue, IsMember = true, MemberName = memberValue });
Add SqlFunc.GetSelfAndAutoFill
2017-07-17 12:56:21 +08:00
}
else
{
foreach (var item in args)
-
2017-04-30 16:11:51 +08:00
{
Optimization analysis
2017-08-13 21:34:29 +08:00
AppendItem(parameter, name, args, model, item);
-
2017-04-30 16:11:51 +08:00
}
Add SqlFunc.GetSelfAndAutoFill
2017-07-17 12:56:21 +08:00
if (appendArgs != null)
-
2017-04-30 16:11:51 +08:00
{
Add SqlFunc.GetSelfAndAutoFill
2017-07-17 12:56:21 +08:00
model.Args.AddRange(appendArgs);
-
2017-04-30 16:11:51 +08:00
}
}
Subquery
2017-09-16 16:01:26 +08:00
if (parameter.BaseParameter.BaseParameter.BaseParameter == null)
Support Select (it=>SqlFun.XXX (it=>it.Id))
2017-09-11 13:24:48 +08:00
{
Rename
2018-11-26 23:29:00 +08:00
this.Context.Result.Append(GetMethodValue(name, model));
Support Select (it=>SqlFun.XXX (it=>it.Id))
2017-09-11 13:24:48 +08:00
}
else
{
Rename
2018-11-26 23:29:00 +08:00
parameter.BaseParameter.CommonTempData = GetMethodValue(name, model);
Support Select (it=>SqlFun.XXX (it=>it.Id))
2017-09-11 13:24:48 +08:00
}
-
2017-04-30 16:11:51 +08:00
}
Exp to sql support conditional ? true : false
2019-02-09 18:49:32 +08:00
protected void Where(ExpressionParameter parameter, bool? isLeft, string name, IEnumerable<Expression> args, MethodCallExpressionModel model, List<MethodCallExpressionArgs> appendArgs = null)
-
2017-04-30 16:11:51 +08:00
{
foreach (var item in args)
{
Expression Bug
2017-12-19 16:20:35 +08:00
var expItem = item;
Update exp to sql
2019-05-15 18:11:44 +08:00
if (item is UnaryExpression)
{
Expression Bug
2017-12-19 16:20:35 +08:00
expItem = (item as UnaryExpression).Operand;
}
AppendItem(parameter, name, args, model, expItem);
-
2017-04-30 16:11:51 +08:00
}
Support System.Date.addXXX
2017-07-16 04:35:42 +08:00
if (appendArgs != null)
{
model.Args.AddRange(appendArgs);
}
Rename
2018-11-26 23:29:00 +08:00
var methodValue = GetMethodValue(name, model);
Update exp to sql
2019-05-15 18:11:44 +08:00
if (parameter.BaseExpression is BinaryExpression && parameter.OppsiteExpression.Type == UtilConstants.BoolType && name == "HasValue" && !(parameter.OppsiteExpression is BinaryExpression) && !(parameter.OppsiteExpression is MethodCallExpression && parameter.OppsiteExpression.Type == UtilConstants.BoolType))
Update Expression To Sql
2019-04-15 17:33:33 +08:00
{
methodValue = packIfElse(methodValue);
}
Update exp to sql
2019-05-15 18:11:44 +08:00
if (parameter.OppsiteExpression != null && name == "IsNullOrEmpty" && parameter.OppsiteExpression.Type == UtilConstants.BoolType && parameter.OppsiteExpression is ConstantExpression)
Update Expression To Sql
2019-04-15 17:33:33 +08:00
{
methodValue = packIfElse(methodValue);
Optimized expression
2017-11-13 12:50:55 +08:00
}
Update exp to sql
2019-02-09 20:53:44 +08:00
var isRoot = contextIndex == 2;
Update exp to sql
2019-05-15 18:11:44 +08:00
if (isRoot && parameter.BaseExpression == null && this.Context.ResolveType.IsIn(ResolveExpressType.WhereMultiple, ResolveExpressType.WhereSingle) && (parameter.CurrentExpression is MethodCallExpression) && ((parameter.CurrentExpression as MethodCallExpression).Method.Name.IsIn("ToBool", "ToBoolean")))
Update Exp to sql
2019-02-06 19:53:24 +08:00
{
methodValue = methodValue + "=1 ";
Update exp to sql
2019-05-15 18:11:44 +08:00
;
}
if (isRoot && parameter.BaseExpression == null && this.Context.ResolveType.IsIn(ResolveExpressType.WhereMultiple, ResolveExpressType.WhereSingle) && (parameter.CurrentExpression is ConditionalExpression) && ((parameter.CurrentExpression as ConditionalExpression).Type == UtilConstants.BoolType))
Update exp to sql
2019-02-09 20:53:44 +08:00
{
methodValue = methodValue + "=1 ";
}
Update exp to sql
2019-05-15 18:11:44 +08:00
if (isRoot && parameter.BaseExpression == null && this.Context.ResolveType.IsIn(ResolveExpressType.WhereMultiple, ResolveExpressType.WhereSingle) && (parameter.CurrentExpression is MethodCallExpression) && ((parameter.CurrentExpression as MethodCallExpression).Method.Name.IsIn("IIF")) && (parameter.CurrentExpression as MethodCallExpression).Method.ReturnType == UtilConstants.BoolType)
Update exp to sql
2019-02-09 20:53:44 +08:00
{
methodValue = methodValue + "=1 ";
}
Update exp to sql
2019-05-15 18:11:44 +08:00
if (parameter.BaseExpression != null && ExpressionTool.IsLogicOperator(parameter.BaseExpression) && this.Context.ResolveType.IsIn(ResolveExpressType.WhereMultiple, ResolveExpressType.WhereSingle) && (parameter.CurrentExpression is ConditionalExpression) && ((parameter.CurrentExpression as ConditionalExpression).Type == UtilConstants.BoolType))
Update exp to sql
2019-02-09 21:21:44 +08:00
{
methodValue = methodValue + "=1 ";
}
if (parameter.BaseExpression != null && ExpressionTool.IsLogicOperator(parameter.BaseExpression) && this.Context.ResolveType.IsIn(ResolveExpressType.WhereMultiple, ResolveExpressType.WhereSingle) && (parameter.CurrentExpression is MethodCallExpression) && ((parameter.CurrentExpression as MethodCallExpression).Method.Name.IsIn("IIF")) && (parameter.CurrentExpression as MethodCallExpression).Method.ReturnType == UtilConstants.BoolType)
{
methodValue = methodValue + "=1 ";
}
Update exp to sql
2019-05-15 18:11:44 +08:00
if (parameter.BaseExpression != null && ExpressionTool.IsLogicOperator(parameter.BaseExpression) && this.Context.ResolveType.IsIn(ResolveExpressType.WhereMultiple, ResolveExpressType.WhereSingle) && (parameter.CurrentExpression is MethodCallExpression) && ((parameter.CurrentExpression as MethodCallExpression).Method.Name.IsIn("ToBool", "ToBoolean")))
update exp to sql
2019-02-09 21:24:31 +08:00
{
methodValue = methodValue + "=1 ";
}
-
2017-04-30 16:11:51 +08:00
base.AppendValue(parameter, isLeft, methodValue);
}
Optimization analysis
2017-08-13 21:34:29 +08:00
Update Expression To Sql
2019-04-15 17:33:33 +08:00
private object packIfElse(object methodValue)
{
methodValue = this.Context.DbMehtods.CaseWhen(new List<KeyValuePair<string, string>>() {
new KeyValuePair<string, string>("IF",methodValue.ObjToString()),
new KeyValuePair<string, string>("Return","1"),
new KeyValuePair<string, string>("End","0")
});
return methodValue;
}
Optimization analysis
2017-08-13 21:34:29 +08:00
private void AppendItem(ExpressionParameter parameter, string name, IEnumerable<Expression> args, MethodCallExpressionModel model, Expression item)
{
Update exp tosql
2019-04-26 19:53:51 +08:00
if (ExpressionTool.IsUnConvertExpress(item))
{
item = (item as UnaryExpression).Operand;
}
Optimization analysis
2017-08-13 21:34:29 +08:00
var isBinaryExpression = item is BinaryExpression || item is MethodCallExpression;
-
2017-08-14 00:01:01 +08:00
var isConst = item is ConstantExpression;
Subquery
2017-09-16 16:01:26 +08:00
var isIIF = name == "IIF";
Code optimization
2017-08-25 22:22:12 +08:00
var isIFFBoolMember = isIIF && (item is MemberExpression) && (item as MemberExpression).Type == UtilConstants.BoolType;
var isIFFUnary = isIIF && (item is UnaryExpression) && (item as UnaryExpression).Operand.Type == UtilConstants.BoolType;
var isIFFBoolBinary = isIIF && (item is BinaryExpression) && (item as BinaryExpression).Type == UtilConstants.BoolType;
var isIFFBoolMethod = isIIF && (item is MethodCallExpression) && (item as MethodCallExpression).Type == UtilConstants.BoolType;
-
2017-08-14 00:01:01 +08:00
var isFirst = item == args.First();
Optimization analysis
2017-08-14 00:39:25 +08:00
if (isFirst && isIIF && isConst)
-
2017-08-14 00:01:01 +08:00
{
var value = (item as ConstantExpression).Value.ObjToBool() ? this.Context.DbMehtods.True() : this.Context.DbMehtods.False();
var methodCallExpressionArgs = new MethodCallExpressionArgs()
{
Optimization analysis
2017-08-14 00:39:25 +08:00
IsMember = true,
-
2017-08-14 00:01:01 +08:00
MemberName = value,
Optimization analysis
2017-08-14 00:39:25 +08:00
MemberValue = value
-
2017-08-14 00:01:01 +08:00
};
model.Args.Add(methodCallExpressionArgs);
}
else if (isIFFUnary && !isFirst)
Optimization analysis
2017-08-13 21:34:29 +08:00
{
AppendModelByIIFMember(parameter, model, (item as UnaryExpression).Operand);
}
-
2017-08-14 00:01:01 +08:00
else if (isIFFBoolMember && !isFirst)
Optimization analysis
2017-08-13 21:34:29 +08:00
{
AppendModelByIIFMember(parameter, model, item);
}
-
2017-08-14 00:01:01 +08:00
else if (isIFFBoolBinary && !isFirst)
Optimization analysis
2017-08-13 21:34:29 +08:00
{
AppendModelByIIFBinary(parameter, model, item);
}
Subquery
2017-09-16 16:01:26 +08:00
else if (isIFFBoolMethod && !isFirst)
{
Optimization analysis
2017-08-14 00:39:25 +08:00
AppendModelByIIFMethod(parameter, model, item);
}
Optimization analysis
2017-08-13 21:34:29 +08:00
else if (isBinaryExpression)
{
model.Args.Add(GetMethodCallArgs(parameter, item));
}
else
{
AppendModel(parameter, model, item);
}
}
Update exp tosql
2019-04-26 19:53:51 +08:00
Optimization analysis
2017-08-13 21:34:29 +08:00
private void AppendModelByIIFMember(ExpressionParameter parameter, MethodCallExpressionModel model, Expression item)
{
parameter.CommonTempData = CommonTempDataType.Result;
base.Expression = item;
base.Start();
var methodCallExpressionArgs = new MethodCallExpressionArgs()
{
IsMember = parameter.ChildExpression is MemberExpression,
MemberName = parameter.CommonTempData
};
if (methodCallExpressionArgs.IsMember && parameter.ChildExpression != null && parameter.ChildExpression.ToString() == "DateTime.Now")
{
methodCallExpressionArgs.IsMember = false;
}
var value = methodCallExpressionArgs.MemberName;
if (methodCallExpressionArgs.IsMember)
{
var childExpression = parameter.ChildExpression as MemberExpression;
if (childExpression.Expression != null && childExpression.Expression is ConstantExpression)
{
methodCallExpressionArgs.IsMember = false;
}
}
if (methodCallExpressionArgs.IsMember == false)
{
var parameterName = this.Context.SqlParameterKeyWord + ExpressionConst.MethodConst + this.Context.ParameterIndex;
this.Context.ParameterIndex++;
methodCallExpressionArgs.MemberName = parameterName;
methodCallExpressionArgs.MemberValue = value;
this.Context.Parameters.Add(new SugarParameter(parameterName, value));
}
model.Args.Add(methodCallExpressionArgs);
parameter.ChildExpression = null;
}
private void AppendModelByIIFBinary(ExpressionParameter parameter, MethodCallExpressionModel model, Expression item)
{
Optimization analysis
2017-08-14 00:39:25 +08:00
Check.Exception(true, "The SqlFunc.IIF(arg1,arg2,arg3) , {0} argument do not support ", item.ToString());
}
private void AppendModelByIIFMethod(ExpressionParameter parameter, MethodCallExpressionModel model, Expression item)
{
var methodExpression = item as MethodCallExpression;
Subquery
2017-09-16 16:01:26 +08:00
if (methodExpression.Method.Name.IsIn("ToBool", "ToBoolean", "IIF"))
Optimization analysis
2017-08-13 21:34:29 +08:00
{
Optimization analysis
2017-08-14 00:39:25 +08:00
model.Args.Add(base.GetMethodCallArgs(parameter, item));
Optimization analysis
2017-08-13 21:34:29 +08:00
}
Optimization analysis
2017-08-14 00:39:25 +08:00
else
Optimization analysis
2017-08-13 21:34:29 +08:00
{
Optimization analysis
2017-08-14 00:39:25 +08:00
Check.Exception(true, "The SqlFunc.IIF(arg1,arg2,arg3) , {0} argument do not support ", item.ToString());
Optimization analysis
2017-08-13 21:34:29 +08:00
}
}
private void AppendModel(ExpressionParameter parameter, MethodCallExpressionModel model, Expression item)
Support method nesting
2017-06-12 17:47:25 +08:00
{
parameter.CommonTempData = CommonTempDataType.Result;
base.Expression = item;
Update Expression to sql
2019-04-15 12:32:02 +08:00
if (item.Type == UtilConstants.DateType && parameter.CommonTempData.ObjToString() == CommonTempDataType.Result.ToString() && item.ToString() == "DateTime.Now.Date")
{
parameter.CommonTempData = DateTime.Now.Date;
}
Update exp to sql
2019-05-28 18:46:44 +08:00
else if (IsDateDate(item))
{
parameter.CommonTempData = GetNewExpressionValue(item);
}
Update exp to sql
2019-06-02 18:32:57 +08:00
else if (IsDateValue(item))
{
parameter.CommonTempData = GetNewExpressionValue(item);
}
Update exp to sql
2019-05-15 18:11:44 +08:00
else if (model.Name == "ToString" && item is ConstantExpression && (item as ConstantExpression).Type.IsEnum())
Update exp to sql
2019-04-28 14:39:24 +08:00
{
parameter.CommonTempData = item.ToString();
}
else
{
Update Expression to sql
2019-04-15 12:32:02 +08:00
base.Start();
}
Support method nesting
2017-06-12 17:47:25 +08:00
var methodCallExpressionArgs = new MethodCallExpressionArgs()
{
Add SqlFunc.MergeString
2017-11-07 16:13:22 +08:00
IsMember = parameter.ChildExpression is MemberExpression && !ExpressionTool.IsConstExpression(parameter.ChildExpression as MemberExpression),
Support method nesting
2017-06-12 17:47:25 +08:00
MemberName = parameter.CommonTempData
};
if (methodCallExpressionArgs.IsMember && parameter.ChildExpression != null && parameter.ChildExpression.ToString() == "DateTime.Now")
{
methodCallExpressionArgs.IsMember = false;
}
var value = methodCallExpressionArgs.MemberName;
if (methodCallExpressionArgs.IsMember)
{
var childExpression = parameter.ChildExpression as MemberExpression;
if (childExpression.Expression != null && childExpression.Expression is ConstantExpression)
{
methodCallExpressionArgs.IsMember = false;
}
}
Update exp to sql
2020-10-27 15:21:26 +08:00
if (IsDateDate(item) || IsDateValue(item))
Update exp to sql
2019-05-28 18:46:44 +08:00
{
methodCallExpressionArgs.IsMember = true;
}
Update exp to sql
2019-05-15 18:11:44 +08:00
if (methodCallExpressionArgs.IsMember == false && (item is MethodCallExpression && item.ToString() == "GetDate()") || (item is UnaryExpression && ((UnaryExpression)item).Operand.ToString() == "GetDate()"))
{
Update exp to sql
2019-04-15 21:27:57 +08:00
var parameterName = this.Context.SqlParameterKeyWord + ExpressionConst.MethodConst + this.Context.ParameterIndex;
this.Context.ParameterIndex++;
methodCallExpressionArgs.MemberName = value;
methodCallExpressionArgs.MemberValue = null;
}
else if (methodCallExpressionArgs.IsMember == false)
Support method nesting
2017-06-12 17:47:25 +08:00
{
var parameterName = this.Context.SqlParameterKeyWord + ExpressionConst.MethodConst + this.Context.ParameterIndex;
this.Context.ParameterIndex++;
methodCallExpressionArgs.MemberName = parameterName;
methodCallExpressionArgs.MemberValue = value;
this.Context.Parameters.Add(new SugarParameter(parameterName, value));
}
model.Args.Add(methodCallExpressionArgs);
Update Expression Resolve
2017-06-15 07:43:58 +08:00
parameter.ChildExpression = null;
Support method nesting
2017-06-12 17:47:25 +08:00
}
-
2017-01-31 20:13:22 +08:00
Update exp to sql
2019-05-28 18:46:44 +08:00
private static bool IsDateDate(Expression item)
{
Update exp to sql
2020-10-27 15:21:26 +08:00
return item.Type == UtilConstants.DateType && item is MemberExpression && (item as MemberExpression).Member.Name == "Date" && item.ToString() != "DateTime.Now.Date";
Update exp to sql
2019-05-28 18:46:44 +08:00
}
Update exp to sql
2019-06-02 18:32:57 +08:00
private static bool IsDateValue(Expression item)
{
Update exp to sql
2020-10-27 15:21:26 +08:00
return item.Type == UtilConstants.IntType &&
item is MemberExpression &&
(item as MemberExpression).Expression != null &&
(item as MemberExpression).Expression.Type == UtilConstants.DateType &&
(item as MemberExpression).Expression is MemberExpression &&
((item as MemberExpression).Expression as MemberExpression).Member.Name == "Value";
Update exp to sql
2019-06-02 18:32:57 +08:00
}
Update exp to sql
2019-05-28 18:46:44 +08:00
Rename
2018-11-26 23:29:00 +08:00
private object GetMethodValue(string name, MethodCallExpressionModel model)
StringIsNullOrEmpty
2017-01-30 15:10:54 +08:00
{
Support custom SqlFunc Method
2017-11-17 14:08:25 +08:00
if (IsExtMethod(name))
{
Update exp to sql
2020-10-27 15:21:26 +08:00
model.Expression = this.Expression;
model.BaseExpression = this.BaseParameter.CurrentExpression;
Support custom SqlFunc Method
2017-11-17 14:08:25 +08:00
DbType type = DbType.SqlServer;
if (this.Context is SqlServerExpressionContext)
type = DbType.SqlServer;
else if (this.Context is MySqlExpressionContext)
type = DbType.MySql;
else if (this.Context is SqliteExpressionContext)
type = DbType.Sqlite;
Update exp to sql
2019-05-15 18:11:44 +08:00
else if (this.Context is OracleExpressionContext)
Support custom SqlFunc Method
2017-11-17 14:08:25 +08:00
type = DbType.Oracle;
Update .net
2021-06-19 12:52:23 +08:00
else if (this.Context is PostgreSQLExpressionContext)
type = DbType.PostgreSQL;
Update exp to sql
2019-05-15 18:11:44 +08:00
return this.Context.SqlFuncServices.First(it => it.UniqueMethodName == name).MethodValue(model, type, this.Context);
Support custom SqlFunc Method
2017-11-17 14:08:25 +08:00
}
else
{
Update exp to sql
2020-10-27 15:21:26 +08:00
if (name == "Parse" && TempParseType.IsIn(UtilConstants.GuidType) && model.Args != null && model.Args.Count() > 1)
Soupport Int.Parse
2019-02-06 17:53:40 +08:00
{
name = "Equals";
}
Update exp to sql
2019-05-15 18:11:44 +08:00
else if (name == "Parse")
Soupport Int.Parse
2019-02-06 17:53:40 +08:00
{
Update exp to sql
2019-05-15 18:11:44 +08:00
name = "To" + TempParseType.Name;
Soupport Int.Parse
2019-02-06 17:53:40 +08:00
}
Expression support IsNullOrWhiteSpace
2020-12-04 19:52:19 +08:00
else if (name == "IsNullOrWhiteSpace")
{
name = "IsNullOrEmpty";
}
Support custom SqlFunc Method
2017-11-17 14:08:25 +08:00
switch (name)
{
case "IIF":
return this.Context.DbMehtods.IIF(model);
case "HasNumber":
return this.Context.DbMehtods.HasNumber(model);
case "HasValue":
return this.Context.DbMehtods.HasValue(model);
case "IsNullOrEmpty":
return this.Context.DbMehtods.IsNullOrEmpty(model);
case "ToLower":
return this.Context.DbMehtods.ToLower(model);
case "ToUpper":
return this.Context.DbMehtods.ToUpper(model);
case "Trim":
return this.Context.DbMehtods.Trim(model);
case "Contains":
return this.Context.DbMehtods.Contains(model);
case "ContainsArray":
Update exp to sql
2019-06-01 12:20:22 +08:00
if (model.Args[0].MemberValue == null)
{
var first = this.Context.Parameters.FirstOrDefault(it => it.ParameterName == model.Args[0].MemberName.ObjToString());
if (first.HasValue())
{
model.Args[0].MemberValue = first.Value;
}
}
Support custom SqlFunc Method
2017-11-17 14:08:25 +08:00
var caResult = this.Context.DbMehtods.ContainsArray(model);
this.Context.Parameters.RemoveAll(it => it.ParameterName == model.Args[0].MemberName.ObjToString());
return caResult;
Add SqlFunc.ContainsArrayUseSqlParameters
2019-06-09 20:51:57 +08:00
case "ContainsArrayUseSqlParameters":
if (model.Args[0].MemberValue == null)
{
var first = this.Context.Parameters.FirstOrDefault(it => it.ParameterName == model.Args[0].MemberName.ObjToString());
if (first.HasValue())
{
model.Args[0].MemberValue = first.Value;
}
}
Update exp to sql
2020-10-27 15:21:26 +08:00
model.Data = this.Context.SqlParameterKeyWord + "INP_" + this.Context.ParameterIndex;
Add SqlFunc.ContainsArrayUseSqlParameters
2019-06-09 20:51:57 +08:00
this.Context.ParameterIndex++;
if (model.Args[0].MemberValue.HasValue())
{
var inValueIEnumerable = (IEnumerable)model.Args[0].MemberValue;
int i = 0;
Update exp to sql
2020-10-27 15:21:26 +08:00
foreach (var item in inValueIEnumerable)
Add SqlFunc.ContainsArrayUseSqlParameters
2019-06-09 20:51:57 +08:00
{
Update exp to sql
2020-10-27 15:21:26 +08:00
this.Context.Parameters.Add(new SugarParameter(model.Data + "_" + i, item));
Add SqlFunc.ContainsArrayUseSqlParameters
2019-06-09 20:51:57 +08:00
i++;
}
}
var caResult2 = this.Context.DbMehtods.ContainsArrayUseSqlParameters(model);
this.Context.Parameters.RemoveAll(it => it.ParameterName == model.Args[0].MemberName.ObjToString());
return caResult2;
Support custom SqlFunc Method
2017-11-17 14:08:25 +08:00
case "Equals":
return this.Context.DbMehtods.Equals(model);
Add Sunfunc.EqualsNull
2020-10-29 17:15:23 +08:00
case "EqualsNull":
return this.Context.DbMehtods.EqualsNull(model);
Support custom SqlFunc Method
2017-11-17 14:08:25 +08:00
case "DateIsSame":
if (model.Args.Count == 2)
return this.Context.DbMehtods.DateIsSameDay(model);
else
{
var dsResult = this.Context.DbMehtods.DateIsSameByType(model);
this.Context.Parameters.RemoveAll(it => it.ParameterName == model.Args[2].MemberName.ObjToString());
return dsResult;
}
case "DateAdd":
if (model.Args.Count == 2)
return this.Context.DbMehtods.DateAddDay(model);
else
{
var daResult = this.Context.DbMehtods.DateAddByType(model);
this.Context.Parameters.RemoveAll(it => it.ParameterName == model.Args[2].MemberName.ObjToString());
return daResult;
}
case "DateValue":
var dvResult = this.Context.DbMehtods.DateValue(model);
this.Context.Parameters.RemoveAll(it => it.ParameterName == model.Args[1].MemberName.ObjToString());
return dvResult;
case "Between":
return this.Context.DbMehtods.Between(model);
case "StartsWith":
return this.Context.DbMehtods.StartsWith(model);
case "EndsWith":
return this.Context.DbMehtods.EndsWith(model);
case "ToInt32":
return this.Context.DbMehtods.ToInt32(model);
case "ToInt64":
return this.Context.DbMehtods.ToInt64(model);
case "ToDate":
return this.Context.DbMehtods.ToDate(model);
-
2019-02-06 18:04:56 +08:00
case "ToDateTime":
return this.Context.DbMehtods.ToDate(model);
Support custom SqlFunc Method
2017-11-17 14:08:25 +08:00
case "ToTime":
return this.Context.DbMehtods.ToTime(model);
case "ToString":
Update exp to sql
2019-05-15 18:11:44 +08:00
if (model.Args.Count > 1 && model.Args.Last().MemberValue.ObjToString().IsContainsIn("-", "/", ":", "yy", "ms", "hh"))
{
return GeDateFormat(model.Args.Last().MemberValue.ObjToString(), model.Args.First().MemberName.ObjToString());
}
Support custom SqlFunc Method
2017-11-17 14:08:25 +08:00
Check.Exception(model.Args.Count > 1, "ToString (Format) is not supported, Use ToString().If time formatting can be used it.Date.Year+\"-\"+it.Data.Month+\"-\"+it.Date.Day ");
return this.Context.DbMehtods.ToString(model);
Add Sqlfunc.ToVarchar
2020-05-25 18:27:16 +08:00
case "ToVarchar":
return this.Context.DbMehtods.ToVarchar(model);
Support custom SqlFunc Method
2017-11-17 14:08:25 +08:00
case "ToDecimal":
return this.Context.DbMehtods.ToDecimal(model);
case "ToGuid":
return this.Context.DbMehtods.ToGuid(model);
case "ToDouble":
return this.Context.DbMehtods.ToDouble(model);
case "ToBool":
return this.Context.DbMehtods.ToBool(model);
-
2019-02-06 18:04:56 +08:00
case "ToBoolean":
return this.Context.DbMehtods.ToBool(model);
Support custom SqlFunc Method
2017-11-17 14:08:25 +08:00
case "Substring":
return this.Context.DbMehtods.Substring(model);
case "Replace":
return this.Context.DbMehtods.Replace(model);
case "Length":
return this.Context.DbMehtods.Length(model);
case "AggregateSum":
return this.Context.DbMehtods.AggregateSum(model);
case "AggregateAvg":
return this.Context.DbMehtods.AggregateAvg(model);
case "AggregateMin":
return this.Context.DbMehtods.AggregateMin(model);
case "AggregateMax":
return this.Context.DbMehtods.AggregateMax(model);
case "AggregateCount":
return this.Context.DbMehtods.AggregateCount(model);
Add SqlFunc.AggregateDistinctCount
2019-05-25 07:29:17 +08:00
case "AggregateDistinctCount":
return this.Context.DbMehtods.AggregateDistinctCount(model);
Support custom SqlFunc Method
2017-11-17 14:08:25 +08:00
case "MappingColumn":
var mappingColumnResult = this.Context.DbMehtods.MappingColumn(model);
var isValid = model.Args[0].IsMember && model.Args[1].IsMember == false;
Code optimization
2021-01-07 11:29:43 +08:00
//Check.Exception(!isValid, "SqlFunc.MappingColumn parameters error, The property name on the left, string value on the right");
Support custom SqlFunc Method
2017-11-17 14:08:25 +08:00
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());
rename
2021-04-24 12:36:39 +08:00
case "SelectAll":
Support custom SqlFunc Method
2017-11-17 14:08:25 +08:00
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();
Add SqlFunc.GetRandom
2018-09-29 14:44:05 +08:00
case "GetRandom":
return this.Context.DbMehtods.GetRandom();
Add Sqlfunc.CharIndex
2019-05-14 13:11:07 +08:00
case "CharIndex":
return this.Context.DbMehtods.CharIndex(model);
Add SqlFunc.BiwiseAnd BiwiselusiveOR
2020-11-07 12:54:42 +08:00
case "BitwiseAnd":
return this.Context.DbMehtods.BitwiseAnd(model);
case "BitwiseInclusiveOR":
return this.Context.DbMehtods.BitwiseInclusiveOR(model);
Add SqlFunc.toDateShort
2020-11-22 14:31:22 +08:00
case "ToDateShort":
return this.Context.DbMehtods.ToDateShort(model);
Add sqlfunc tochar todate datediff
2021-02-04 17:18:21 +08:00
case "Oracle_ToChar":
return this.Context.DbMehtods.Oracle_ToChar(model);
case "Oracle_ToDate":
return this.Context.DbMehtods.Oracle_ToDate(model);
case "SqlServer_DateDiff":
return this.Context.DbMehtods.SqlServer_DateDiff(model);
Support custom SqlFunc Method
2017-11-17 14:08:25 +08:00
default:
break;
}
StringIsNullOrEmpty
2017-01-30 15:10:54 +08:00
}
return null;
}
Add SqlFunc.MergeString
2017-11-07 16:13:22 +08:00
private bool IsContainsArray(MethodCallExpression express, string methodName, bool isValidNativeMethod)
-
2017-09-16 21:56:53 +08:00
{
return !isValidNativeMethod && express.Method.DeclaringType.Namespace.IsIn("System.Linq", "System.Collections.Generic") && methodName == "Contains";
}
Subquery
2017-09-16 16:01:26 +08:00
Add SqlFunc.MergeString
2017-11-07 16:13:22 +08:00
private bool IsSubMethod(MethodCallExpression express, string methodName)
Subquery
2017-09-16 16:01:26 +08:00
{
-
2017-09-17 01:22:06 +08:00
return SubTools.SubItemsConst.Any(it => it.Name == methodName) && express.Object != null && express.Object.Type.Name == "Subqueryable`1";
Subquery
2017-09-16 16:01:26 +08:00
}
-
2017-11-28 12:45:43 +08:00
private bool CheckMethod(MethodCallExpression expression)
StringIsNullOrEmpty
2017-01-30 15:10:54 +08:00
{
rename
2021-04-24 12:36:39 +08:00
if (expression.Method.Name=="SelectAll")
{
return true;
}
-
2017-11-28 12:45:43 +08:00
if (IsExtMethod(expression.Method.Name))
return true;
Update exp to sql
2019-05-15 18:11:44 +08:00
if (IsParseMethod(expression))
Soupport Int.Parse
2019-02-06 17:53:40 +08:00
return true;
Update exp to sql
2019-05-15 18:11:44 +08:00
if (expression.Method.Name == "IsNullOrEmpty" && expression.Method.DeclaringType == UtilConstants.StringType)
Update exp to sql
2019-02-06 21:44:51 +08:00
{
return true;
}
Expression support IsNullOrWhiteSpace
2020-12-04 19:52:19 +08:00
if (expression.Method.Name == "IsNullOrWhiteSpace" && expression.Method.DeclaringType == UtilConstants.StringType)
{
return true;
}
-
2017-11-28 12:45:43 +08:00
if (expression.Method.ReflectedType().FullName != ExpressionConst.SqlFuncFullName)
return false;
else
return true;
Ok
2017-01-07 21:54:51 +08:00
}
Soupport Int.Parse
2019-02-06 17:53:40 +08:00
private Type TempParseType;
Update exp to sql
2019-05-15 18:11:44 +08:00
public bool IsParseMethod(MethodCallExpression expression)
Soupport Int.Parse
2019-02-06 17:53:40 +08:00
{
Update exp to sql
2019-05-15 18:11:44 +08:00
if (expression.Method.Name == "Parse" && expression.Method.DeclaringType.IsIn(
UtilConstants.DecType,
UtilConstants.DateType,
UtilConstants.DobType,
UtilConstants.GuidType,
UtilConstants.FloatType,
UtilConstants.ShortType,
UtilConstants.LongType,
UtilConstants.IntType,
UtilConstants.BoolType))
Soupport Int.Parse
2019-02-06 17:53:40 +08:00
{
TempParseType = expression.Method.DeclaringType;
Update exp to sql
2019-05-15 18:11:44 +08:00
return true;
Soupport Int.Parse
2019-02-06 17:53:40 +08:00
}
return false;
}
Update exp to sql
2019-05-15 18:11:44 +08:00
public string GeDateFormat(string formatString, string value)
{
var parameter = new MethodCallExpressionArgs() { IsMember = true, MemberValue = DateType.Year };
var parameter2 = new MethodCallExpressionArgs() { IsMember = true, MemberName = value };
var parameters = new MethodCallExpressionModel() { Args = new List<MethodCallExpressionArgs>() { parameter2, parameter } };
var begin = @"^";
var end = @"$";
formatString = formatString.Replace("yyyy", begin + UtilMethods.ConvertStringToNumbers(this.GetMethodValue("DateValue", parameters).ObjToString()) + end);
formatString = formatString.Replace("yy", begin + UtilMethods.ConvertStringToNumbers(this.GetMethodValue("DateValue", parameters).ObjToString()) + end);
parameters.Args.Last().MemberValue = DateType.Month;
Update exp date.ToString("yyyy-MM-dd")
2021-04-25 17:17:27 +08:00
if (IsMySql())
{
formatString = formatString.Replace("MM", begin + UtilMethods.ConvertStringToNumbers("LPAD(" + this.GetMethodValue("DateValue", parameters).ObjToString() + ",2,0)") + end);
}
else if (IsSqlite())
{
formatString = formatString.Replace("MM", begin + UtilMethods.ConvertStringToNumbers("SUBSTR('00' ||" + this.GetMethodValue("DateValue", parameters).ObjToString() + ", -2, 2)") + end);
}
else if (IsPg())
{
formatString = formatString.Replace("MM", begin + UtilMethods.ConvertStringToNumbers("lpad(cast(" + this.GetMethodValue("DateValue", parameters).ObjToString() + " as varchar(20)),2,'0')") + end);
}
else if (IsOracle())
{
formatString = formatString.Replace("MM", begin + UtilMethods.ConvertStringToNumbers("lpad(cast(" + this.GetMethodValue("DateValue", parameters).ObjToString() + " as varchar(20)),2,'0')") + end);
}
else
{
formatString = formatString.Replace("MM", begin + UtilMethods.ConvertStringToNumbers(this.GetMethodValue("DateValue", parameters).ObjToString()) + end);
}
Update exp to sql
2019-05-15 18:11:44 +08:00
formatString = formatString.Replace("M", begin + UtilMethods.ConvertStringToNumbers(this.GetMethodValue("DateValue", parameters).ObjToString()) + end);
parameters.Args.Last().MemberValue = DateType.Day;
formatString = formatString.Replace("dd", begin + UtilMethods.ConvertStringToNumbers(this.GetMethodValue("DateValue", parameters).ObjToString()) + end);
formatString = formatString.Replace("d", begin + UtilMethods.ConvertStringToNumbers(this.GetMethodValue("DateValue", parameters).ObjToString()) + end);
parameters.Args.Last().MemberValue = DateType.Hour;
formatString = Regex.Replace(formatString, "hh", begin + UtilMethods.ConvertStringToNumbers(this.GetMethodValue("DateValue", parameters).ObjToString()) + end, RegexOptions.IgnoreCase);
formatString = Regex.Replace(formatString, "h", begin + UtilMethods.ConvertStringToNumbers(this.GetMethodValue("DateValue", parameters).ObjToString()) + end, RegexOptions.IgnoreCase);
parameters.Args.Last().MemberValue = DateType.Minute;
formatString = formatString.Replace("mm", begin + UtilMethods.ConvertStringToNumbers(this.GetMethodValue("DateValue", parameters).ObjToString()) + end);
formatString = formatString.Replace("m", begin + UtilMethods.ConvertStringToNumbers(this.GetMethodValue("DateValue", parameters).ObjToString()) + end);
parameters.Args.Last().MemberValue = DateType.Second;
formatString = formatString.Replace("ss", begin + UtilMethods.ConvertStringToNumbers(this.GetMethodValue("DateValue", parameters).ObjToString()) + end);
formatString = formatString.Replace("s", begin + UtilMethods.ConvertStringToNumbers(this.GetMethodValue("DateValue", parameters).ObjToString()) + end);
Update exp date.ToString("yyyy-MM-dd")
2021-04-25 17:17:27 +08:00
if (!IsSqlite())
{
parameters.Args.Last().MemberValue = DateType.Millisecond;
formatString = formatString.Replace("ms", begin + UtilMethods.ConvertStringToNumbers(this.GetMethodValue("DateValue", parameters).ObjToString()) + end);
}
Update exp to sql
2019-05-15 18:11:44 +08:00
var items = Regex.Matches(formatString, @"\^\d+\$").Cast<Match>().ToList();
foreach (var item in items)
{
formatString = formatString.Replace(item.Value, "$@" + UtilMethods.ConvertNumbersToString(item.Value.TrimStart('^').TrimEnd('$')) + "$");
}
var strings = formatString.TrimStart('$').TrimEnd('$').Split('$');
var joinStringParameter = new MethodCallExpressionModel()
{
Args = new List<MethodCallExpressionArgs>()
};
foreach (var r in strings)
{
if (r.Substring(0, 1) == "@")
{
joinStringParameter.Args.Add(new MethodCallExpressionArgs()
{
Update exp to sql
2020-10-27 15:21:26 +08:00
MemberName = r.TrimStart('@')
Update exp to sql
2019-05-15 18:11:44 +08:00
});
}
else
{
var name = base.AppendParameter(r);
joinStringParameter.Args.Add(new MethodCallExpressionArgs()
{
Update exp to sql
2020-10-27 15:21:26 +08:00
MemberName = name
Update exp to sql
2019-05-15 18:11:44 +08:00
});
}
}
return this.GetMethodValue("MergeString", joinStringParameter).ObjToString();
}
Update exp date.ToString("yyyy-MM-dd")
2021-04-25 17:17:27 +08:00
private bool IsMySql()
{
return this.Context is MySqlExpressionContext;
}
private bool IsSqlite()
{
return this.Context is SqliteExpressionContext;
}
private bool IsPg()
{
return this.Context is PostgreSQLExpressionContext;
}
private bool IsOracle()
{
return this.Context is OracleExpressionContext;
}
Ok
2017-01-07 21:54:51 +08:00
}
}
Reference in New Issue Copy Permalink