protected override Expression VisitMethodCall(MethodCallExpression node)
{
Expression retExpr = null;
if (node.Method.Name == _functionName)
{
var str = node.ToString();
MethodCall call;
if (_methodCalls.TryGetValue(str, out call))
{
++call.CallCount;
}
else
{
call = new MethodCall(node, Expression.Parameter(node.Type, "param" + (_methodCalls.Count)));
_methodCalls.Add(str, call);
}
retExpr = call.Parameter;
}
else
retExpr = base.VisitMethodCall(node);
return retExpr;
}
public bool CanHandle(MethodCallExpression expression)
{
//Contract.Assert(expression.Method != null);
return expression.Method.DeclaringType == typeof(string)
&& (expression.Method.Name == "ToLower" || expression.Method.Name == "ToLowerInvariant");
}
protected override SequenceConvertInfo Convert(
ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo, ParameterExpression param)
{
var predicate = (LambdaExpression)methodCall.Arguments[1].Unwrap();
var info = builder.ConvertSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]), predicate.Parameters[0]);
if (info != null)
{
info.Expression = methodCall.Transform(ex => ConvertMethod(methodCall, 0, info, predicate.Parameters[0], ex));
if (param != null)
{
if (param.Type != info.Parameter.Type)
param = Expression.Parameter(info.Parameter.Type, param.Name);
if (info.ExpressionsToReplace != null)
foreach (var path in info.ExpressionsToReplace)
{
path.Path = path.Path.Transform(e => e == info.Parameter ? param : e);
path.Expr = path.Expr.Transform(e => e == info.Parameter ? param : e);
}
}
info.Parameter = param;
return info;
}
return null;
}
private void HandleGroupBy(System.Linq.Expressions.MethodCallExpression m)
{
Linq.Visitors.Select.PostfixSelectVisitor svst = new Linq.Visitors.Select.PostfixSelectVisitor(row, s => NHEX.Projections.GroupProperty(s));
LambdaExpression lambda = (LambdaExpression)Linq.Utils.Expression.StripQuotes(m.Arguments[1]);
Expression exp = svst.Visit(lambda.Body);
//If there are no projection there is no more work to do.
if (svst.ListOfProjections.Count == 0)
{
return;
}
Translation.projector = Expression.Lambda(exp, row);
for (Int32 I = 0; I < svst.ListOfProjections.Count; ++I)
{
String projectedName = svst.ProjectionsPropertyNames[I];
projectedProperties.AddLast(projectedName);
if (projectedName.Contains("."))
{
rootCriteria.SetFetchMode(projectedName.Substring(0, projectedName.LastIndexOf('.')), FetchMode.Join);
}
Linq.Utils.NHibernate.AddProjectionToCriteria(
NHEX.Projections.GroupProperty(projectedName), rootCriteria);
}
//The m.type is the return value, it is an IEnumerable<IGrouping<T, S>>
//Linq.Utils.LinqGroupingResultTransformer transformer =
// new NHibernate.Linq.Utils.LinqGroupingResultTransformer(
// m.Type.GetGenericArguments()[0], svst.ProjectionsPropertyNames[0]);
//rootCriteria.SetResultTransformer(transformer);
}
// Copied this method from Microsoft.Web.Mvc.dll (MVC Futures)...
// Microsoft.Web.Mvc.Internal.ExpresisonHelper.AddParameterValuesFromExpressionToDictionary().
// The only change I made is saving the parameter values to TempData instead
// of a RouteValueDictionary.
private IDictionary<string, object> AddParameterValuesFromExpressionToTempData(TempDataDictionary tempData,
MethodCallExpression call)
{
ParameterInfo[] parameters = call.Method.GetParameters();
var parsedParameters = new Dictionary<string, object>();
if(parameters.Length > 0)
{
for(int i = 0; i < parameters.Length; i++)
{
Expression expression = call.Arguments[i];
object obj2 = null;
ConstantExpression expression2 = expression as ConstantExpression;
if(expression2 != null)
{
obj2 = expression2.Value;
}
else
{
Expression<Func<object>> expression3 =
Expression.Lambda<Func<object>>(Expression.Convert(expression, typeof(object)),
new ParameterExpression[0]);
obj2 = expression3.Compile()();
}
tempData[RedirectParameterPrefix + parameters[i].Name] = obj2;
parsedParameters.Add(parameters[i].Name, obj2);
}
}
return parsedParameters;
}
private static bool ArrayAgg(MethodCallExpression methodCall, StringBuilder queryBuilder, Action<Expression> visitExpression)
{
var typeName = GetTypeName(methodCall.Type);
if (typeName == null)
return false;
var sqe = methodCall.Arguments[0] as SubQueryExpression;
if (sqe != null)
{
var me = sqe.QueryModel.SelectClause.Selector as MemberExpression;
queryBuilder.Append("(SELECT cast(collect(");
if (me != null)
queryBuilder.Append('"').Append(me.Member.Name).Append('"');
else //TODO detect supported selectors - only identity
visitExpression(sqe.QueryModel.SelectClause.Selector);
queryBuilder.Append(')');
}
else queryBuilder.Append("SELECT cast(collect($sq) ");
queryBuilder.Append(" AS ").Append(typeName).Append(") FROM ");
if (methodCall.Arguments[0] is MemberExpression)
queryBuilder.Append("TABLE(");
else queryBuilder.Append('(');
visitExpression(methodCall.Arguments[0]);
queryBuilder.Append(") $sq)");
return true;
}
public Expression Translate(MethodCallExpression methodCallExpression, N1QlExpressionTreeVisitor expressionTreeVisitor)
{
if (methodCallExpression == null)
{
throw new ArgumentNullException("methodCallExpression");
}
var argument = methodCallExpression.Arguments[0];
var methodCallArgument = argument as MethodCallExpression;
if ((methodCallArgument != null) && SupportMethods.Contains(methodCallArgument.Method))
{
// Two method calls are reversing each other, so just skip them both
return expressionTreeVisitor.VisitExpression(methodCallArgument.Arguments[0]);
}
var expression = expressionTreeVisitor.Expression;
if (methodCallExpression.Method.Name == "FromDateTime")
{
expression.Append("STR_TO_MILLIS(");
}
else
{
expression.Append("MILLIS_TO_STR(");
}
expressionTreeVisitor.VisitExpression(argument);
expression.Append(')');
return methodCallExpression;
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
if (sequence.SelectQuery.Select.TakeValue != null || sequence.SelectQuery.Select.SkipValue != null)
sequence = new SubQueryContext(sequence);
var lambda = (LambdaExpression)methodCall.Arguments[1].Unwrap();
var sparent = sequence.Parent;
var order = new ExpressionContext(buildInfo.Parent, sequence, lambda);
var body = lambda.Body.Unwrap();
var sql = builder.ConvertExpressions(order, body, ConvertFlags.Key);
builder.ReplaceParent(order, sparent);
if (!methodCall.Method.Name.StartsWith("Then"))
sequence.SelectQuery.OrderBy.Items.Clear();
foreach (var expr in sql)
{
var e = builder.ConvertSearchCondition(sequence, expr.Sql);
sequence.SelectQuery.OrderBy.Expr(e, methodCall.Method.Name.EndsWith("Descending"));
}
return sequence;
}
protected override Expression VisitMethodCall(MethodCallExpression methodCallExpression)
{
if (methodCallExpression.Method.DeclaringType == typeof(Queryable))
{
if (methodCallExpression.Method.IsGenericMethod
&& methodCallExpression.Arguments.Count == 2)
{
switch (methodCallExpression.Method.Name)
{
case "First":
case "FirstOrDefault":
case "Single":
case "SingleOrDefault":
case "Count":
break;
default:
return base.VisitMethodCall(methodCallExpression);
}
var type = methodCallExpression.Method.GetGenericArguments()[0];
var call = (Expression)Expression.Call(null, MethodInfoFastRef.QueryableWhereMethod.MakeGenericMethod(type), methodCallExpression.Arguments[0], methodCallExpression.Arguments[1]);
var method = methodCallExpression.Method.ReflectedType
.GetMethods()
.Single(c => c.Name == methodCallExpression.Method.Name && c.GetParameters().Length == 1 && c.GetParameters()[0].ParameterType == typeof(IQueryable<>).MakeGenericType(c.GetGenericArguments()[0]));
call = Expression.Call(null, method.MakeGenericMethod(type), call);
return call;
}
}
return base.VisitMethodCall(methodCallExpression);
}
/// <summary>
/// Initializes a new instance of the <see cref="ObjectDeserialiserQuerySink"/> class.
/// </summary>
/// <param name="originalType">the original type that the query was made against.</param>
/// <param name="instanceType">the type of the object that must be returned.</param>
/// <param name="instanceName">Name of the instance (i.e the alias used in both the LINQ and SPARQL queries).</param>
/// <param name="distinct">if set to <c>true</c> discard duplicate answers.</param>
/// <param name="selectExpression">The select expression (derived from the the LINQ query). Used to help in deserialisation.</param>
/// <param name="context">The data context that will monitor the objects created (not yet used).</param>
public ObjectDeserialiserQuerySink(
Type originalType,
Type instanceType,
string instanceName,
bool distinct,
MethodCallExpression selectExpression,
RdfDataContext context)
{
#region Tracing
#line hidden
if (Logger.IsDebugEnabled)
{
Logger.Debug("Deserialising {0}.", instanceType.Name);
}
#line default
#endregion
SelectExpression = selectExpression;
this.originalType = originalType;
this.instanceType = instanceType;
InstanceName = instanceName;
Distinct = distinct;
DataContext = context;
IncomingResults = new ArrayList();
}
internal override Expression VisitMethodCall(MethodCallExpression m)
{
Expression obj = this.Visit(m.Object);
ReadOnlyCollection<Expression> args = this.VisitExpressionList(m.Arguments);
// check for args changed
if (obj != m.Object || args != m.Arguments)
{
MethodInfo mInfo = m.Method;
Type[] typeArgs = (mInfo.IsGenericMethod) ? mInfo.GetGenericArguments() : null;
if ((mInfo.IsStatic || mInfo.DeclaringType.IsAssignableFrom(obj.Type))
&& ArgsMatch(mInfo, args, typeArgs))
{
// current method is still valid
return Expression.Call(obj, mInfo, args);
}
else if (mInfo.DeclaringType == typeof(Queryable))
{
// convert Queryable method to Enumerable method
MethodInfo seqMethod = FindEnumerableMethod(mInfo.Name, args, typeArgs);
args = this.FixupQuotedArgs(seqMethod, args);
return Expression.Call(obj, seqMethod, args);
}
else
{
// rebind to new method
MethodInfo method = FindMethod(mInfo.DeclaringType, mInfo.Name, args, typeArgs);
args = this.FixupQuotedArgs(method, args);
return Expression.Call(obj, method, args);
}
}
return m;
}
private static string VisitMethod(MethodCallExpression expression, string currentClause)
{
currentClause = VisitExpression(expression.Object, currentClause);
var argVals = MethodExpressionArgumentEvaluator.EvaluateArguments(expression);
var matchFormat = expression.Method.GetCustomAttribute<ParseToCypherAttribute>().Format;
return currentClause + String.Format(matchFormat, argVals);
}
protected override Expression VisitMethodCallExpression(MethodCallExpression expression)
{
var method = expression.Method.IsGenericMethod
? expression.Method.GetGenericMethodDefinition()
: expression.Method;
if (_pagingMethods.Contains(method) && !_sessionFactory.Dialect.SupportsVariableLimit)
{
//TODO: find a way to make this code cleaner
var query = VisitExpression(expression.Arguments[0]);
var arg = expression.Arguments[1];
if (query == expression.Arguments[0])
return expression;
return Expression.Call(null, expression.Method, query, arg);
}
if (VisitorUtil.IsDynamicComponentDictionaryGetter(expression, _sessionFactory))
{
return expression;
}
return base.VisitMethodCallExpression(expression);
}
protected override Expression VisitMethodCall (MethodCallExpression methodCall)
{
if (IsQueryableExtension (methodCall.Method))
return ReplaceQueryableMethod (methodCall);
return base.VisitMethodCall (methodCall);
}
/// <summary>
/// Translates Joins from type (1) to type (2)
/// 1) Join(outer, inner, c => c.outerKey, c => d.innerKey, (x, y) => new { x.a.b.c, y.a.b.c })
/// 2) Join(outer, inner, c => c.outerKey, c => d.innerKey, (x, y) => new { x, y }).Select(c => new { c.x.a.b.c, c.y.a.b.v })
/// </summary>
protected Expression RewriteExplicitJoinProjection(MethodCallExpression methodCallExpression)
{
var outer = this.Visit(methodCallExpression.Arguments[0]);
var inner = this.Visit(methodCallExpression.Arguments[1]);
var outerKeySelector = methodCallExpression.Arguments[2].StripQuotes();
var innerKeySelector = methodCallExpression.Arguments[3].StripQuotes();
var resultSelector = methodCallExpression.Arguments[4].StripQuotes();
var originalOuterKeyParam = resultSelector.StripQuotes().Parameters[0];
var originalInnerKeyParam = resultSelector.StripQuotes().Parameters[1];
var outerKey = Expression.Parameter(outerKeySelector.Parameters[0].Type);
var innerKey = Expression.Parameter(innerKeySelector.Parameters[0].Type);
var resultValue = Expression.Parameter(typeof(ExpandedJoinSelectKey<,>).MakeGenericType(outerKey.Type, innerKey.Type));
var newResultSelector = Expression.Lambda(Expression.MemberInit(resultValue.Type.CreateNewExpression(), Expression.Bind(resultValue.Type.GetProperty("Outer"), outerKey), Expression.Bind(resultValue.Type.GetProperty("Inner"), innerKey)), outerKey, innerKey);
var newJoin = Expression.Call(null, MethodInfoFastRef.QueryableJoinMethod.MakeGenericMethod(outer.Type.GetSequenceElementType() ?? outer.Type, inner.Type.GetSequenceElementType() ?? inner.Type, outerKeySelector.ReturnType, newResultSelector.ReturnType), outer, inner, outerKeySelector, innerKeySelector, newResultSelector);
var selectorParameter = Expression.Parameter(resultValue.Type);
var selectProjectorBody = SqlExpressionReplacer.Replace(resultSelector.Body, originalOuterKeyParam, Expression.Property(selectorParameter, "Outer"));
selectProjectorBody = SqlExpressionReplacer.Replace(selectProjectorBody, originalInnerKeyParam, Expression.Property(selectorParameter, "Inner"));
var selectProjector = Expression.Lambda(selectProjectorBody, selectorParameter);
var select = Expression.Call(null, MethodInfoFastRef.QueryableSelectMethod.MakeGenericMethod(selectorParameter.Type, selectProjector.ReturnType), newJoin, selectProjector);
return select;
}
public override bool CanHandle(MethodCallExpression expression)
{
//////Contract.Assert(expression.Method != null);
return expression.Method.DeclaringType == typeof(Math)
&& expression.Method.Name == "Floor";
}
/// <summary>
/// 访问指定的方法
/// </summary>
/// <param name="theEntityType">实体的类型</param>
/// <param name="m">访问方法调用相关的表达式</param>
/// <param name="tableAlias">表的别名</param>
/// <param name="colConditionParts">存储条件节点的栈</param>
/// <param name="colParameterNames">存储参数名称的列表</param>
/// <param name="colDbTypes">存储数据库字段类型的列表</param>
/// <param name="colArguments">存储条件值的列表</param>
public static void Visit(Type theEntityType, MethodCallExpression m, string tableAlias, Stack<string> colConditionParts, List<string> colParameterNames, List<DbType> colDbTypes, List<object> colArguments)
{
if (m.Object is MemberExpression)
{
//类似n.Name.StartsWith("吴")这样的调用
if (m.Object.Type == typeof(string))
{
StringMethodCallVisitor.Visit(theEntityType, m, tableAlias, colConditionParts, colParameterNames, colDbTypes, colArguments);
}
else
{
throw new Exception("暂不支持{" + m.ToString() + "}的调用!");
}
}
else if (m.Object is ConstantExpression)
{
//类似"ABCD".Contains(n.Name)这样的调用
var cons = m.Object as ConstantExpression;
if (cons.Type == typeof(string))
{
StringMethodCallVisitor.Visit(theEntityType, m, tableAlias, colConditionParts, colParameterNames, colDbTypes, colArguments);
}
else
{
throw new Exception("暂不支持{" + m.ToString() + "}的调用!");
}
}
else
{
throw new Exception("暂不支持{" + m.ToString() + "}的调用!");
}
}
/// <summary>
/// Determines whether the expression represents a supported method call.
/// </summary>
/// <param name="expression">The expression.</param>
/// <remarks></remarks>
public override BindingSignatureSupport IsSupportedMethod(MethodCallExpression expression)
{
switch (expression.Method.Name)
{
case "Equals":
return new BindingSignatureSupport(SignatureSupportType.SupportedAsFieldValue, ValuePredicateType.Equal);
case "StartsWith":
return new BindingSignatureSupport(SignatureSupportType.SupportedAsFieldValue, ValuePredicateType.StartsWith);
case "EndsWith":
return new BindingSignatureSupport(SignatureSupportType.SupportedAsFieldValue, ValuePredicateType.EndsWith);
case "get_Item":
// This is the default accessor of a Dictionary, so check if the parent object is supported too
if (ExpressionHelper.IsMember(expression.Object) && IsSupportedMember(expression.Object as MemberExpression).SignatureSupportType != SignatureSupportType.NotSupported)
return new BindingSignatureSupport(SignatureSupportType.SupportedAsFieldName, ValuePredicateType.Equal);
break;
}
// Add support for dynamic expressions using an intermediary set of "fake" methods on DynamicMemberMetadata
if (expression.Method == DynamicMemberMetadata.GetMemberMethod)
{
var firstArg = expression.Arguments[0] as ConstantExpression;
if (firstArg != null)
switch (firstArg.Value as string)
{
case "NodeTypeAlias":
case "ContentTypeAlias":
case "MediaTypeAlias":
return new BindingSignatureSupport(SignatureSupportType.SupportedAsSchemaAlias, ValuePredicateType.Empty);
}
return new BindingSignatureSupport(SignatureSupportType.SupportedAsFieldName, ValuePredicateType.Empty);
}
return new BindingSignatureSupport(SignatureSupportType.SupportedAsFieldName, ValuePredicateType.Equal);
}
/// <summary>
/// ((PromotionEvaluationContext)x).IsItemInProduct(ProductId)
/// </summary>
/// <returns></returns>
public linq.Expression <Func <IEvaluationContext, bool> > GetConditionExpression()
{
if (ProductId == null && ProductIds == null)
{
throw new ArgumentException($"{nameof(ProductId)} and {nameof(ProductIds)} cannot be null.");
}
var paramX = linq.Expression.Parameter(typeof(IEvaluationContext), "x");
var castOp = linq.Expression.MakeUnary(linq.ExpressionType.Convert, paramX, typeof(PromotionEvaluationContext));
linq.MethodCallExpression methodCall = null;
if (ProductIds != null)
{
var methodInfo = typeof(PromotionEvaluationContextExtension).GetMethod("IsItemInProducts");
methodCall = linq.Expression.Call(null, methodInfo, castOp, ProductIds.GetNewArrayExpression());
}
else
{
var methodInfo = typeof(PromotionEvaluationContextExtension).GetMethod("IsItemInProduct");
methodCall = linq.Expression.Call(null, methodInfo, castOp, linq.Expression.Constant(ProductId));
}
var retVal = linq.Expression.Lambda <Func <IEvaluationContext, bool> >(methodCall, paramX);
return(retVal);
}
private Expression Convert(LinqExp.MethodCallExpression linqCall)
{
return(Expression.Call(
ConvertExp(linqCall.Object),
linqCall.Method,
Convert(linqCall.Arguments)));
}
protected Expression RewriteSelectManyProjection(MethodCallExpression methodCallExpression)
{
var outer = this.Visit(methodCallExpression.Arguments[0]);
var collection = this.Visit(methodCallExpression.Arguments[1]);
var resultSelector = methodCallExpression.Arguments[2].StripQuotes();
var originalSelectorA = resultSelector.StripQuotes().Parameters[0];
var originalSelectorB = resultSelector.StripQuotes().Parameters[1];
var newA = Expression.Parameter(originalSelectorA.Type);
var newB = Expression.Parameter(originalSelectorB.Type);
var resultValue = Expression.Parameter(typeof(ExpandedJoinSelectKey<,>).MakeGenericType(originalSelectorA.Type, originalSelectorB.Type));
var newResultSelector = Expression.Lambda(Expression.MemberInit(resultValue.Type.CreateNewExpression(), Expression.Bind(resultValue.Type.GetProperty("Outer"), newA), Expression.Bind(resultValue.Type.GetProperty("Inner"), newB)), newA, newB);
var newSelectMany = Expression.Call(null, MethodInfoFastRef.QueryableSelectManyMethod.MakeGenericMethod(methodCallExpression.Method.GetGenericArguments()[0], methodCallExpression.Method.GetGenericArguments()[1], newResultSelector.ReturnType), outer, collection, newResultSelector);
var selectorParameter = Expression.Parameter(resultValue.Type);
var selectProjectorBody = SqlExpressionReplacer.Replace(resultSelector.Body, originalSelectorA, Expression.Property(selectorParameter, "Outer"));
selectProjectorBody = SqlExpressionReplacer.Replace(selectProjectorBody, originalSelectorB, Expression.Property(selectorParameter, "Inner"));
var selectProjector = Expression.Lambda(selectProjectorBody, selectorParameter);
var select = Expression.Call(null, MethodInfoFastRef.QueryableSelectMethod.MakeGenericMethod(selectorParameter.Type, selectProjector.ReturnType), newSelectMany, selectProjector);
return select;
}
protected override Expression VisitMethodCall(MethodCallExpression methodCallExpression)
{
Check.NotNull(methodCallExpression, nameof(methodCallExpression));
if (methodCallExpression.Method.IsGenericMethod)
{
var methodInfo = methodCallExpression.Method.GetGenericMethodDefinition();
if (ReferenceEquals(methodInfo, EntityQueryModelVisitor.PropertyMethodInfo))
{
var newArg0 = Visit(methodCallExpression.Arguments[0]);
if (newArg0 != methodCallExpression.Arguments[0])
{
return Expression.Call(
methodCallExpression.Method,
newArg0,
methodCallExpression.Arguments[1]);
}
return methodCallExpression;
}
}
return base.VisitMethodCall(methodCallExpression);
}
static Expression RewriteIsAnyMethod(MethodCallExpression expression)
{
return Expression.Call(
typeof(Arg),
"Any",
new[] { expression.Method.GetFirstTypeArgument() });
}
/// <summary>
/// Replaces calls to DbContext.Set() with an expression for the equivalent <see cref="ObjectQuery" />.
/// </summary>
/// <param name="node"> The node to replace. </param>
/// <returns> A new node, which may have had the replacement made. </returns>
protected override Expression VisitMethodCall(MethodCallExpression node)
{
Check.NotNull(node, "node");
// We are looking for either the generic or non-generic Set method on DbContext.
// However, we don't constrain to this so if you write your own parameterless method on
// a derived DbContext, then we will work with this as well.
if (typeof(DbContext).IsAssignableFrom(node.Method.DeclaringType))
{
var memberExpression = node.Object as MemberExpression;
if (memberExpression != null)
{
// Only try to invoke the method if it is on the context, is not parameterless, and is not attributed
// as a function.
var context = GetContextFromConstantExpression(memberExpression.Expression, memberExpression.Member);
if (context != null
&&
!node.Method.GetCustomAttributes(typeof(DbFunctionAttribute), false).Any()
&&
node.Method.GetParameters().Length == 0)
{
var expression =
CreateObjectQueryConstant(
node.Method.Invoke(context, SetAccessBindingFlags, null, null, null));
if (expression != null)
{
return expression;
}
}
}
}
return base.VisitMethodCall(node);
}
protected override Expression VisitMethodCall(MethodCallExpression methodCallExpression)
{
var newMethodCallExpression = (MethodCallExpression)base.VisitMethodCall(methodCallExpression);
if (EntityQueryModelVisitor.IsPropertyMethod(methodCallExpression.Method))
{
var subQueryExpression = newMethodCallExpression.Arguments[0] as SubQueryExpression;
var subSelector = subQueryExpression?.QueryModel.SelectClause.Selector as QuerySourceReferenceExpression;
if (subSelector != null)
{
var subQueryModel = subQueryExpression.QueryModel;
subQueryModel.SelectClause.Selector
= methodCallExpression
.Update(
null,
new[]
{
subSelector,
methodCallExpression.Arguments[1]
});
subQueryModel.ResultTypeOverride = subQueryModel.SelectClause.Selector.Type;
return new SubQueryExpression(subQueryModel);
}
}
return newMethodCallExpression;
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
if (node.Method.DeclaringType == typeof(Queryable))
{
switch (node.Method.Name)
{
case "OrderBy":
TranslateToOrderBy(node);
break;
case "Where":
if (wherepredicate != "")
wherepredicate += " and " + Environment.NewLine;
wherepredicate += predicateBuilder.TranslateToWhere(node);
break;
case "OfType":
if (wherepredicate != "")
wherepredicate += " and " + Environment.NewLine;
wherepredicate += predicateBuilder.TranslateToOfType(node);
break;
case "Take":
TranslateToTake(node);
break;
case "Select":
documentDataSelector = selectorBuilder.TranslateToProjection(node);
break;
default:
throw new NotSupportedException(string.Format("Method {0} is not yet supported",
node.Method.Name));
}
}
return base.VisitMethodCall(node);
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
return Expression.Call(
Visit(node.Object),
node.Method,
node.Arguments.Select(n => Visit(n)));
}
static Expression RewriteIsMethod(MethodCallExpression expression)
{
var argument = (ConstantExpression)expression.Arguments[0];
var valueExpression = Expression.Constant(argument.Value);
return Expression.Call(typeof(Arg), "Is", new[] { argument.Type }, valueExpression);
}
protected override QueryNode VisitMethodCall(MethodCallExpression methodCall)
{
MethodInfo method = methodCall.Method;
if (method.DeclaringType == typeof (Queryable) || method.DeclaringType == typeof (QueryableExtensions))
return base.VisitMethodCall(methodCall);
// PATCH: this fixes querying on interfaces using indexers
if (method.DeclaringType == ItemType || (method.DeclaringType != null && method.DeclaringType.IsAssignableFrom(ItemType)))
return VisitItemMethod(methodCall);
// END PATCH
if (method.DeclaringType == typeof (string) || method.DeclaringType == typeof (MethodExtensions))
return base.VisitMethodCall(methodCall);
// PATCH: this fixes querying using ICollections on interfaces
if (method.DeclaringType != null && method.DeclaringType.GetInterfaces().Any(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(ICollection<>)))
{
return VisitICollectionMethod(methodCall);
}
// END PATCH
if (method.DeclaringType == typeof(Enumerable) && methodCall.Arguments.Count > 0 && methodCall.Arguments.First() is MemberExpression)
{
Type declaringType = ((MemberExpression)methodCall.Arguments.First()).Member.DeclaringType;
// PATCH: fixes querying on interfaces using LINQ Enumerable extension methods
if (declaringType == ItemType || (declaringType != null && declaringType.IsAssignableFrom(ItemType)))
return VisitLinqEnumerableExtensionMethod(methodCall);
}
return EvaluateMethodCall(methodCall);
}
public Expression Translate(MethodCallExpression methodCallExpression, N1QlExpressionTreeVisitor expressionTreeVisitor)
{
if (methodCallExpression == null)
{
throw new ArgumentNullException("methodCallExpression");
}
var expression = expressionTreeVisitor.Expression;
expression.Append("(");
expressionTreeVisitor.VisitExpression(methodCallExpression.Object);
expression.Append(" LIKE '%");
var indexInsertStarted = expression.Length;
expressionTreeVisitor.VisitExpression(methodCallExpression.Arguments[0]);
var indexInsertEnded = expression.Length;
expression.Append("%')");
//Remove extra quote marks which have been added due to the string in the clause, these aren't needed as they have been added already in this case.
expression.Remove(indexInsertStarted, 1);
expression.Remove(indexInsertEnded - 2, 1);
return methodCallExpression;
}
private void CreatePropertyExpressions()
{
var name = Expression.Constant(_property.Name, typeof(string));
_containsKey = Expression.Call(_param, DictionaryContainsKeyMethod, name);
_nameProperty = Expression.Property(_obj, _property);
_itemProperty = Expression.Property(_param, DictionaryIndexerProperty, name);
}
public void TestFunctionCall()
{
//Expression.Call()
string[,] gradeArray =
{ { "chemistry", "history", "mathematics" }, { "78", "61", "82" } };
System.Linq.Expressions.Expression arrayExpression =
System.Linq.Expressions.Expression.Constant(gradeArray);
// Create a MethodCallExpression that represents indexing
// into the two-dimensional array 'gradeArray' at (0, 2).
// Executing the expression would return "mathematics".
System.Linq.Expressions.MethodCallExpression methodCallExpression =
System.Linq.Expressions.Expression.ArrayIndex(
arrayExpression,
System.Linq.Expressions.Expression.Constant(0),
System.Linq.Expressions.Expression.Constant(2));
var writeLineExpression = Expression.Call(null,
typeof(Trace).GetMethod("WriteLine", new Type[] { typeof(object) }) ??
throw new InvalidOperationException(),
Expression.Constant("this is a test"));
var innerLabel = Expression.Label();
var expressionBlock = Expression.Block(Expression.Label(innerLabel), writeLineExpression);
var block = Expression.Block(Expression.Goto(innerLabel), expressionBlock);
var compiledCode = Expression.Lambda <Action>(block).Compile();
compiledCode();
}
private void VisitMethodCall(MethodCallExpression expression)
{
VisitExpression(expression.Object);
string methodName = expression.Method.Name;
object objToInvokeUpon = returnValueFromLastExpressionVisit;
MethodInfo methodInfo = objToInvokeUpon.GetType().GetMethod(methodName,
BindingFlags.Public | BindingFlags.Instance);
int paramCount = methodInfo.GetParameters().Count();
Array paramArray = Array.CreateInstance(typeof (Object), paramCount);
for (int arrLocation = 0; arrLocation < expression.Arguments.Count; arrLocation++)
{
Expression argument = expression.Arguments[arrLocation];
VisitExpression(argument);
if (argument is ConstantExpression)
{
object argValue = ((ConstantExpression) argument).Value;
paramArray.SetValue(argValue, arrLocation);
}
else
{
object argValue = returnValueFromLastExpressionVisit;
paramArray.SetValue(argValue, arrLocation);
Console.WriteLine();
}
}
var array = (object[]) paramArray;
returnValueFromLastExpressionVisit = methodInfo.Invoke(objToInvokeUpon, array);
if (returnValueFromLastExpressionVisit is Pattern)
{
m_pattern = (Pattern) returnValueFromLastExpressionVisit;
}
}
public Expression Translate(MethodCallExpression methodCallExpression, N1QlExpressionTreeVisitor expressionTreeVisitor)
{
if (methodCallExpression == null)
{
throw new ArgumentNullException("methodCallExpression");
}
var expression = expressionTreeVisitor.Expression;
expression.Append("SUBSTR(");
expressionTreeVisitor.VisitExpression(methodCallExpression.Object);
expression.Append(", ");
expressionTreeVisitor.VisitExpression(methodCallExpression.Arguments[0]);
if (methodCallExpression.Arguments.Count > 1)
{
expression.Append(", ");
expressionTreeVisitor.VisitExpression(methodCallExpression.Arguments[1]);
}
else if (methodCallExpression.Method.Name == "get_Chars")
{
// Called str[i], so return a single character at i
expression.Append(", 1");
}
expression.Append(")");
return methodCallExpression;
}
protected override LE.Expression VisitCall(LE.MethodCallExpression mce, LE.Expression objectExpr, IEnumerable <LE.Expression> argExpressions)
{
if (objectExpr != null && mce.Method.DeclaringType == typeof(String))
{
return(LE.Expression.Call(objectExpr, mce.Method, argExpressions));
}
return(base.VisitCall(mce, objectExpr, argExpressions));
}
private static Func <AstDecompiler.AstBuilder, MethodDefinition, ConstructorDeclaration> GetConstructorDeclarationDelegate()
{
MethodInfo methodInfo = GetMethodInfo("CreateConstructor");
LinqExpressions.MethodCallExpression methodCall = LinqExpressions.Expression.Call(_builderParameter, methodInfo, _methodDefinitionParameter);
return(LinqExpressions.Expression.Lambda <Func <AstDecompiler.AstBuilder, MethodDefinition, ConstructorDeclaration> >
(methodCall, _builderParameter, _methodDefinitionParameter).Compile());
}
internal static bool TryWriteX(Type tAccessor, DataSet db, DbCommand cmd, out int rslt, System.Linq.Expressions.Expression <Func <DataSet, DbCommand, int> > handlerExpr)
{
System.Linq.Expressions.MethodCallExpression methodCallExpr = (System.Linq.Expressions.MethodCallExpression)handlerExpr.Body;
string handlerMethodName = methodCallExpr.Method.Name;
HandlerExecDesc handler;
if (!s_map_CommandText_Exec_Method.TryGetValue(cmd.CommandText, out handler))
{
// not registered
IComparable handlerCommandText = GetCommandTextImpl(tAccessor, handlerMethodName);
//string handlerCommandText = gct(handlerMethodName);// RepositoryDML_CommandText.RepositoryDML_GetCommandTextDML(handlerMethodName);
string handlerCommandTextX = handlerCommandText as string;
bool isOk;
if (handlerCommandTextX == null)
{
isOk = handlerCommandText.CompareTo(cmd) == 0;
}
else
{
isOk = string.Equals(cmd.CommandText, handlerCommandTextX, StringComparison.Ordinal);
}
if (isOk)
{
var parameter_db = Expression.Parameter(typeof(DataSet), "db");
var parameter_cmd = Expression.Parameter(typeof(DbCommand), "cmd");
MethodCallExpression call = Expression.Call(methodCallExpr.Method, parameter_db, parameter_cmd); // methodCallExpr.Arguments
Expression <Func <DataSet, DbCommand, int> > lambda = Expression.Lambda <Func <DataSet, DbCommand, int> >(call, parameter_db, parameter_cmd); // visitor.ExtractedParameters
Func <DataSet, DbCommand, int> handlerMethod = lambda.Compile();
handler = new HandlerExecDesc(handlerMethodName, handlerMethod);
s_map_CommandText_Exec_Method.Add(cmd.CommandText, handler);
}
else
{
handler = null;
}
}
else
{
// registered
}
if (handler != null && handler.MethodName == handlerMethodName)
{
rslt = handler.HandlerMethod(db, cmd);
return(true);
}
rslt = 0;
return(false);
}
public Expression Parse(Linq.Expression linqExpression)
{
if (linqExpression is Linq.ConstantExpression)
{
Linq.ConstantExpression cexpr = (Linq.ConstantExpression)linqExpression;
if (!(cexpr.Value is double))
{
throw new Exception("Can't parse a non-numeric constant");
}
return(new NumberExpression((double)cexpr.Value));
}
else if (linqExpression is Linq.ParameterExpression)
{
Linq.ParameterExpression pexpr = (Linq.ParameterExpression)linqExpression;
return(new VariableExpression(pexpr.Name));
}
else if (linqExpression is Linq.MethodCallExpression)
{
Linq.MethodCallExpression mexpr = (Linq.MethodCallExpression)linqExpression;
IList <Expression> arguments = new List <Expression>();
foreach (Linq.Expression arg in mexpr.Arguments)
{
arguments.Add(Parse(arg));
}
if (!exists(mexpr.Method))
{
throw new Exception("Method name doesn't exist in the scope");
}
if (mexpr.Method.Equals(powMethod))
{
return(new BinaryExpression(Binary.Power, arguments[0], arguments[1]));
}
string name = get(mexpr.Method);
return(new FunctionExpression(name, arguments));
}
else if (linqExpression is Linq.BinaryExpression)
{
Linq.BinaryExpression bexpr = (Linq.BinaryExpression)linqExpression;
Expression left = Parse(bexpr.Left);
Expression right = Parse(bexpr.Right);
return(new BinaryExpression(getOperator(bexpr.NodeType), left, right));
}
throw new Exception("Can't parse expression");
}
public CommandExecutionHandlerImpl(Type commandTextOwner, bool isProcedureHandler, System.Linq.Expressions.Expression <Func <DataSet, DbCommand, DbDataReader> > handlerExpr)
{
_isProcedureHandler = isProcedureHandler;
System.Linq.Expressions.MethodCallExpression methodCallExpr = (System.Linq.Expressions.MethodCallExpression)handlerExpr.Body;
string handlerMethodName = methodCallExpr.Method.Name;
HandlerMethodOwner = methodCallExpr.Method.DeclaringType;
_handlerMethodName = handlerMethodName;
MethodCallExpr = (System.Linq.Expressions.MethodCallExpression)handlerExpr.Body;
CommandTextOwner = commandTextOwner ?? HandlerMethodOwner;
}
protected override MSAst.Expression VisitMethodCall(MSAst.MethodCallExpression node)
{
var result = base.VisitMethodCall(node);
if (IgnoreMethod(node.Method))
{
// To ignore the called method, we need to prevent its time from being added to the current method's total
return(_profiler.AddInnerProfiling(node, _tick, _profileIndex));
}
return(result);
}
/// <inheritdoc />
protected override Expression VisitMethodCall(MethodCallExpression expression)
{
LogWriter.WriteLine($"VisitMethodCall: {expression}, method {expression.Method.Name}, args: {string.Join(", ",expression.Arguments.Select(a => a.ToString()))}");
var method = expression.Method;
switch (method.Name)
{
case "Contains":
case "StartsWith":
case "EndsWith":
var obj = Evaluate(expression.Object);
var pattern = Evaluate(expression.Arguments[0]);
_state.SetColumn(obj.ToString());
_state.SetFunction(method.Name, pattern);
return(expression);
case "Min":
case "Max":
case "Count":
case "Average":
case "Sum":
using (_state.PushCollectorMode(QueryCollectionState.Aggregate))
{
object value = null;
if (expression.Arguments.Count > 1)
{
throw new InvalidOperationException($"Unsupported number of aggregate function arguments: {expression.Arguments.Count}");
}
if (expression.Arguments.Count > 0)
{
value = Evaluate(expression.Arguments[0]);
}
_state.SetFunction(method.Name, value);
}
return(expression);
case "Column":
var columnName = Evaluate(expression.Arguments[0]).ToString();
_arguments.Push(columnName);
_state.SetColumn(columnName);
return(expression);
}
return(base.VisitMethodCall(expression)); // throws
}
private ParseResult ParseMethodCall(System.Linq.Expressions.MethodCallExpression expr)
{
ParseResult objPart = ParseValueExpression(expr.Object);
string textualPart = objPart == null ? null : objPart.TextualResult;
switch (expr.Method.Name)
{
case "Any":
return(new ParseResult(expr.Type, string.Format("{0}{1}.{2}({3})"
, string.IsNullOrWhiteSpace(textualPart) ? string.Empty : textualPart + "."
, ParseValueExpression(expr.Arguments[0]).TextualResult
, expr.Method.Name
, ParseValueExpression(expr.Arguments[1]).TextualResult
)));
case "Contains":
// we have to express this as [Constant] in [Array].
// our constant is our first element. our array is the second.
if (expr.Method.GetParameters().Count() == 2)
{
var ArrayResult = ParseValueExpression(expr.Arguments[0]);
var ConstantResult = ParseValueExpression(expr.Arguments[1]);
return(new ParseResult(expr.Type, $"{ConstantResult.TextualResult} IN {ArrayResult.TextualResult}"));
}
break;
}
return(new ParseResult(expr.Type, string.Format("{0}{1}({2})"
, string.IsNullOrWhiteSpace(textualPart) ? string.Empty : textualPart + "."
, expr.Method.Name
, string.Join(",", expr.Arguments.Select(a => ParseValueExpression(a).TextualResult)))));
//switch (expr.Method.Name)
//{
// case "Contains":
// case "StartsWith":
// case "EndsWith":
// return string.Format("{0}.{2}({1})"
// , ParseValueExpression(expr.Object)
// , ParseValueExpression(expr.Arguments[0])
// , expr.Method.Name);
// default:
// throw new NotImplementedException();
//}
}
protected override System.Linq.Expressions.Expression VisitMethodCall(System.Linq.Expressions.MethodCallExpression m)
{
switch (m.Method.Name)
{
case "Sum":
return(HandleProjectionOfSingleElement(m, s => NHEX.Projections.Sum(s)));
case "Min":
return(HandleProjectionOfSingleElement(m, s => NHEX.Projections.Min(s)));
case "Max":
return(HandleProjectionOfSingleElement(m, s => NHEX.Projections.Max(s)));
case "Average":
return(HandleProjectionOfSingleElement(m, s => NHEX.Projections.Avg(s)));
}
return(base.VisitMethodCall(m));
}
/// <summary>
/// Handle projection of aggregate, an aggregate is a SUm, Max or other stuff, it is valid only
/// if is a single projection
/// </summary>
/// <param name="m"></param>
private void HandleProjectionOfSingleElement(
System.Linq.Expressions.MethodCallExpression m,
Func <String, NHEX.IProjection> createProjection)
{
if (m.Arguments.Count == 2)
{
throw new ApplicationException("Cannot handle composite aggregation");
//Select.PostfixSelectVisitor svst = new Select.PostfixSelectVisitor(row, s => NHEX.Projections.Property(s));
//svst.Visit(Linq.Utils.Expression.StripQuotes(m.Arguments[1]));
//projectedProperties.AddLast(svst.ProjectionsPropertyNames[0]);
//Linq.Utils.NHibernate.AddProjectionToCriteria(
// createProjection(svst.ProjectionsPropertyNames[0]), rootCriteria);
}
Translation = new AggregateQueryTranslated(this, createProjection)
{
Criteria = rootCriteria
};
}
/// <summary>
/// 获取Lambda表达式返回的结果
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="func"></param>
/// <returns></returns>
public CoreFrameworkEntity GetLambdaEntity <T>(System.Linq.Expressions.Expression <Func <T, bool> > func)
{
listPara.Clear();
CoreFrameworkEntity lambdaEntity = new CoreFrameworkEntity();
// 二元运算符表达式
if (func.Body is System.Linq.Expressions.BinaryExpression)
{
System.Linq.Expressions.BinaryExpression be = ((System.Linq.Expressions.BinaryExpression)func.Body);
lambdaEntity.where = BinarExpressionProvider(be.Left, be.Right, be.NodeType);
lambdaEntity.paraList = listPara;
}
// 单纯的静态方法
if (func.Body is System.Linq.Expressions.MethodCallExpression)
{
System.Linq.Expressions.MethodCallExpression be = ((System.Linq.Expressions.MethodCallExpression)func.Body);
lambdaEntity.where = ExpressionRouter(be);
lambdaEntity.paraList = listPara;
}
return(lambdaEntity);
}
/// <summary>
/// Método acionado quando uma chamada de método é visitada.
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
protected override System.Linq.Expressions.Expression VisitMethodCall(System.Linq.Expressions.MethodCallExpression node)
{
var result = base.VisitMethodCall(node);
if (node.Method.Name == "get_Item" &&
node.Method.DeclaringType == typeof(Accessors.VariavelCollectionValueAccessor))
{
var constantExpression = node.Arguments[0] as System.Linq.Expressions.ConstantExpression;
if (constantExpression != null)
{
var name = constantExpression.Value.ToString();
if (!_provedorDependencias.Variaveis.Contains(name))
{
_provedorDependencias.AdicionarDependencia(name);
}
}
}
return(result);
}
/// <summary>
/// Handle a project
/// </summary>
/// <param name="m"></param>
/// <param name="createProjection"></param>
private LE.Expression HandleProjectionOfSingleElement(
System.Linq.Expressions.MethodCallExpression m,
Func <String, NHEX.IProjection> createProjection)
{
if (m.Arguments.Count == 2)
{
LE.LambdaExpression l = (LE.LambdaExpression)Linq.Utils.Expression.StripQuotes(m.Arguments[1]);
LE.MemberExpression me = (LE.MemberExpression)l.Body;
String memberName = me.Member.Name;
ProjectionsPropertyNames.Add(memberName);
projections.Add(createProjection(memberName));
return(LE.Expression.Convert( //Call the GetValue on row passing currentcolumnindex as argument.
LE.Expression.Call(
row,
miGetValue,
LE.Expression.Constant(currentColumnIndex++)),
me.Type));
}
return(m);
}
/// <summary>
/// Handle the select part of an expression.
/// </summary>
/// <param name="m"></param>
private void HandleSelect(System.Linq.Expressions.MethodCallExpression m)
{
LambdaExpression lambda = (LambdaExpression)Linq.Utils.Expression.StripQuotes(m.Arguments[1]);
Linq.Visitors.Select.PostfixSelectVisitor svst = new Linq.Visitors.Select.PostfixSelectVisitor(row, s => NHEX.Projections.Property(s));
Expression exp = svst.Visit(lambda.Body);
//If there are no projection there is no more work to do.
if (svst.ListOfProjections.Count == 0)
{
return;
}
Translation.projector = Expression.Lambda(exp, row);
for (Int32 I = 0; I < svst.ListOfProjections.Count; ++I)
{
projectedProperties.AddLast(svst.ProjectionsPropertyNames[I]);
Linq.Utils.NHibernate.AddProjectionToCriteria(
svst.ListOfProjections[I], rootCriteria);
}
}
protected override System.Linq.Expressions.Expression VisitMethodCall(System.Linq.Expressions.MethodCallExpression m)
{
var e = base.VisitMethodCall(m) as MethodCallExpression;
if (e.Method.DeclaringType == typeof(System.Linq.Queryable) && e.Method.Name == "Where" && e.Arguments.Count == 2)
{
var p1 = _stack.Pop();
var p2 = _stack.Pop();
if (string.IsNullOrEmpty(p2))
{
_stack.Push(p1);
}
else
{
_stack.Push(p2 + "&" + p1);
}
}
else
{
throw new QueryException();
}
return(e);
}
string MethodExpression(System.Linq.Expressions.Expression exp)
{
System.Linq.Expressions.MethodCallExpression mce = (System.Linq.Expressions.MethodCallExpression)exp;
string key = ExpressionRouter(mce.Arguments[0]);
object obj = RightExpressionRouter(mce.Arguments[1]);
//对象属性
EntityPropColumnAttributes columnAttribute = columnAttrList.Where(w => w.propName == key).First();
key = columnAttribute.fieldName;
//参数名称
string paramName = "@" + key + random.Next(1000, 9999);
if (mce.Method.Name == "Like" || mce.Method.Name == "NotLike")
{
listPara.Add(new SqlParameter(paramName, "%" + obj.ToStr() + "%"));
}
string values = "";
#region 拼接参数值
if (mce.Method.Name == "In" || mce.Method.Name == "NotIn")
{
string json = JsonHelper.Serialize(obj);
List <object> list = JsonHelper.Deserialize <List <object> >(json);
if (list.Count == 0)
{
return(" (1=2) ");
}
int index = 0;
foreach (var value in list)
{
index++;
listPara.Add(new SqlParameter(paramName + index, value.ToStr()));
values += paramName + index + ",";
}
}
values = values.TrimEnd(',');
#endregion
if (mce.Method.Name == "Like")
{
return(string.Format("({0} like {1})", key, paramName));
}
else if (mce.Method.Name == "NotLike")
{
return(string.Format("({0} Not like {1})", key, paramName));
}
else if (mce.Method.Name == "In")
{
return(string.Format("{0} In ({1})", key, values));
}
else if (mce.Method.Name == "NotIn")
{
return(string.Format("{0} Not In ({1})", key, values));
}
return(" (1=2) ");
}
public void 添加数据复杂语句测试lt()
{
string colm1 = "remake", val1 = " (select 666) ";
System.Linq.Expressions.Expression <Func <LockPers, bool[]> > fiesExps =
p => new bool[] { p.Content == "aa", p.IsDel == true, SM.Sql(colm1, val1), SM.Sql(p.Name, " (select 1) ") }; //
System.Linq.Expressions.LambdaExpression colmvalambda = fiesExps as System.Linq.Expressions.LambdaExpression;
System.Linq.Expressions.NewArrayExpression arryexps = colmvalambda.Body as System.Linq.Expressions.NewArrayExpression;
StringBuilder sb = new StringBuilder();
Dapper.DynamicParameters spars = new Dapper.DynamicParameters();
int num = 1;
string exgl = "=";
sb.Append(" ( ");
List <string[]> customColmval = new List <string[]>();
var lmbdParmName = colmvalambda.Parameters[0].Name;
foreach (var p in arryexps.Expressions)
{
if (p.NodeType == System.Linq.Expressions.ExpressionType.Equal)
{
AnalysisExpression.BinaryExprssRowSqlParms(p, sb, spars, num++, exgl, (name, parmasName, exglstr) => string.Format("{0},", name)); //" {0} {2} @{0}{1} "
}
else if (p.NodeType == System.Linq.Expressions.ExpressionType.Call)
{
string[] arrColmval = new string[2]; // 0 column 1 value
System.Linq.Expressions.MethodCallExpression method = p as System.Linq.Expressions.MethodCallExpression;
int i = 0;
tempstart:
//meb = method.Arguments[0] as System.Linq.Expressions.MemberExpression;
if (method.Arguments[i] is System.Linq.Expressions.ConstantExpression)
{
// 参数名/插入值 直接赋值
arrColmval[i] = (method.Arguments[i] as System.Linq.Expressions.ConstantExpression).Value.ToString();
}
else if (method.Arguments[i] is System.Linq.Expressions.MemberExpression)
{// 参数名/插入值 传入的时 变量
var meb = method.Arguments[i] as System.Linq.Expressions.MemberExpression;
if (meb.Expression is System.Linq.Expressions.ParameterExpression &&
(meb.Expression as System.Linq.Expressions.ParameterExpression).Name == lmbdParmName)
{ // lambda表达式的参数成员 表示字段参数名 只取成员名称不取值
arrColmval[i] = (method.Arguments[i] as System.Linq.Expressions.MemberExpression).Member.Name;
}
else
{// 外部传入的变量
arrColmval[i] = AnalysisExpression.GetMemberValue(method.Arguments[i] as System.Linq.Expressions.MemberExpression).ToString();
}
}
//(method.Arguments[i] as System.Linq.Expressions.MemberExpression).Member.Name;
else
{
throw new Exception(p.ToString() + " 插入语句未能解析");
}
if (++i < 2)
{
goto tempstart;
}
customColmval.Add(arrColmval);
}
else
{
throw new Exception(p.ToString() + " 插入语句未能解析");
}
}
sb.Remove(sb.Length - 1, 1);
// 拼接子查询插入的 参数名
sb.Append((spars.ParameterNames.Count() > 0 && customColmval.Count > 0 ? ", " : string.Empty) + string.Join(",", customColmval.Select(p => p[0]).ToList <string>()));
sb.AppendFormat(") values ({0}{1}) "
, string.Join(",", spars.ParameterNames.ToList <string>().Select(p => "@" + p).ToList <string>())
, (spars.ParameterNames.Count() > 0 && customColmval.Count > 0 ? ", " : string.Empty) + string.Join(",", customColmval.Select(p => p[1]).ToList <string>())
);
Console.WriteLine(sb);
return; // ############################################################
}
public override Expression Bind(Expressions.ProjectionExpression projection, ProjectionBindingContext context, System.Linq.Expressions.MethodCallExpression node, IEnumerable <System.Linq.Expressions.Expression> arguments)
{
var aggregatorName = "Single";
var returnType = node.Method.ReturnType;
if (node.Method.Name.EndsWith("Async"))
{
aggregatorName += "Async";
returnType = returnType.GetGenericArguments()[0];
}
var aggregator = CreateAggregator(aggregatorName, returnType);
var source = projection.Source;
var argument = arguments.FirstOrDefault();
if (argument != null && ExtensionExpressionVisitor.IsLambda(argument))
{
var lambda = ExtensionExpressionVisitor.GetLambda(argument);
var binder = new AccumulatorBinder(context.GroupMap, context.SerializerRegistry);
binder.RegisterParameterReplacement(lambda.Parameters[0], projection.Projector);
argument = binder.Bind(lambda.Body);
}
else
{
argument = projection.Projector;
var select = source as SelectExpression;
if (select != null)
{
source = select.Source;
}
}
var serializer = context.SerializerRegistry.GetSerializer(returnType);
var accumulator = new AccumulatorExpression(returnType, AccumulatorType, argument);
var serializationAccumulator = new SerializationExpression(
accumulator,
new BsonSerializationInfo("__agg0", serializer, serializer.ValueType));
var rootAccumulator = new RootAccumulatorExpression(source, serializationAccumulator);
return(new ProjectionExpression(
rootAccumulator,
serializationAccumulator,
aggregator));
}
protected override MSAst.Expression VisitMethodCall(MSAst.MethodCallExpression node)
{
return(VisitCall(base.VisitMethodCall(node)));
}
protected override System.Linq.Expressions.Expression VisitMethodCall(System.Linq.Expressions.MethodCallExpression node)
{
var leftTable = node.Arguments[0];
if (leftTable.NodeType == ExpressionType.Call)
{
var leftCallExp = leftTable as MethodCallExpression;
if (leftCallExp.Method.Name == "NoLock")
{
leftTable = leftCallExp.Arguments[0];
}
}
//JoinExpressionVisitor visitor = null;
var joinName = "<>" + Path.GetRandomFileName();
if (leftTable.NodeType == ExpressionType.Call)
{
var leftMethodCallExp = (MethodCallExpression)leftTable;
var visitorSub = new JoinExpressionVisitor(Context);
visitorSub.Visit(leftTable);
if (node.Method.Name == "SelectMany")
{
SelectExpression = node.Arguments[2];
joinName = ((ParameterExpression)((LambdaExpression)((UnaryExpression)node.Arguments[2]).Operand).Parameters[1]).Name;
var joinTmps = visitorSub.Joins;
var lastJoin = joinTmps.LastOrDefault();
joinTmps.Remove(lastJoin.Key);
// var lockTables = visitor.Result as List<string>;
Joins.Add(joinName, lastJoin.Value);
//foreach (var item in joinTmps)
//{
// if (item.Key == lastJoin.Key)
// {
// continue;
// }
// Joins.Add(item.Key, item.Value);
//}
return(node);
}
//foreach (var item in visitorSub.Joins)
//{
// Joins.Add(item.Key, item.Value);
//}
}
SelectExpression = node.Arguments[4];
//if (leftTable.NodeType == ExpressionType.Call &&
// (((MethodCallExpression)leftTable).Method.Name == "SelectMany" ||
// _joinMethodNames.Contains(((MethodCallExpression)leftTable).Method.Name)))
//{
// visitor = new JoinExpressionVisitor();
// visitor.Visit(leftTable);
// foreach (var item in visitor.Joins)
// {
// Joins.Add(item.Key, item.Value);
// }
// //((List<Join>)Result).AddRange((List<Join>)visitor.Result);
// if (node.Method.Name == "SelectMany")
// {
// return node;
// }
//}
var rightTable = node.Arguments[1];
//var nolockRightTable = false;
if (rightTable.NodeType == ExpressionType.Call)
{
var rightCallExp = (MethodCallExpression)rightTable;
if (rightCallExp.Method.Name != "NoLock")
{
throw new Exception();
}
//nolockRightTable = true;
rightTable = rightCallExp.Arguments[0];
}
if (rightTable.NodeType != ExpressionType.Constant)
{
throw new Exception();
}
var leftColumnExp = node.Arguments[2];
var rightColumnExp = node.Arguments[3];
var memVisitor = new MemberExpressionVisitor(Context);
memVisitor.Visit(leftColumnExp);
if (memVisitor.Token.Type != TokenType.Column)
{
throw new Exception();
}
var join = new Join();
join.Left = memVisitor.Token.Column;
memVisitor = new MemberExpressionVisitor(Context);
memVisitor.Visit(rightColumnExp);
join.Right = memVisitor.Token.Column;
//if (nolockRightTable)
//{
// ((List<string>)Result).Add(join.Right.Table.Alias);
//}
switch (node.Method.Name)
{
case "Join":
join.JoinType = JoinType.Inner;
break;
case "GroupJoin":
join.JoinType = JoinType.Left;
break;
default:
throw new Exception();
}
var resultExp = node.Arguments[4];
var resultCallExp = (LambdaExpression)((LambdaExpression)((UnaryExpression)resultExp).Operand);
Joins.Add(joinName, join);
return(node);
}
public MethodCallExpressionProxy(MethodCallExpression node)
{
ContractUtils.RequiresNotNull(node, nameof(node));
_node = node;
}
