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; }