public IQueryable <TElement> CreateQuery <TElement>(Expression expression) { Expression newExpression = new ExpressionReWriterVisitor(fields, expand).Visit(expression); IQueryable <TElement> query = source.CreateQuery <TElement>(newExpression); return(new ObjectSetEx <TElement>(query, this.fields, this.expand)); }
public IQueryable CreateQuery(Expression expression) { var result = _underlyingQueryProvider.CreateQuery(expression); InvokeCallback("CreateQuery", expression, result); return(_underlyingQueryProvider.CreateQuery(expression)); }
public IQueryable <TElement> CreateQuery <TElement>(Expression expression) { Expression newExpression = ExpressionReWriterVisitor.Default.Visit(expression); IQueryable <TElement> query = source.CreateQuery <TElement>(newExpression); return(new ObjectSetEx <TElement>(query)); }
public virtual IEnumerator <TElement> ExecuteQuery <TElement>(Expression expression) { IQueryable <TElement> query = provider.CreateQuery <TElement>(expression); IEnumerator <TElement> enumerator = query.GetEnumerator(); return(enumerator); }
public IQueryable CreateQuery(Expression expression) { var query = queryProvider.CreateQuery(expression); AddQueryToPipeline(query); return(aggregateQueryable); }
public IQueryable <TElement> CreateQuery <TElement>(Expression expression) { foreach (var visitor in this.expressionVisitors) { expression = visitor.Visit(expression); } return(new InterceptingQuery <TElement>(source.CreateQuery <TElement>(expression), this.expressionVisitors)); }
public IQueryable CreateQuery(Expression expression) { expression = ExpressionVisitor.Visit(expression); var queryable = _queryProvider.CreateQuery(expression); //Wrap queryable to MyQuery class. var makeGenericType = typeof(MyQuery <>).MakeGenericType(queryable.ElementType); return((IQueryable)makeGenericType.GetConstructor(new[] { typeof(IQueryable <>).MakeGenericType(queryable.ElementType) }) .Invoke(new object[] { queryable })); }
public IQueryable <TElement> CreateQuery <TElement>(Expression expression) { Expression expression2 = Manipulator != null?Manipulator(false, expression) : expression; IQueryable <TElement> query = BaseQueryProvider.CreateQuery <TElement>(expression2); IQueryProvider provider = query.Provider; ProxyDbProvider proxy = provider == BaseQueryProvider ? this : new ProxyDbProvider(provider, Manipulator); return(new ProxyQueryable <TElement>(proxy, query)); }
public IQueryable <TElement> CreateQuery <TElement>(Expression expression) { if (!typeof(TElement).IsAssignableFrom(typeof(TData))) { var innerResult = _inner.CreateQuery <TElement>(expression); return(innerResult); } var result = (IQueryable <TElement>)_inner.CreateQuery <TElement>(expression).Cast <TData>(); return((IQueryable <TElement>) new MediaQueryable <TElement, TData>(result)); }
public IQueryable CreateQuery(Expression expression) { var query = queryProvider.CreateQuery(expression); if (query is IAsyncQueryable) { return(query); } var result = (query as IMongoQueryable).AsAsync(); return(result); }
public IQueryable<TElement> CreateQuery<TElement>(Expression expression) { Console.WriteLine("Before:"); Console.WriteLine(expression); Console.WriteLine(); expression = expression.Expand(); Console.WriteLine("After:"); Console.WriteLine(expression); return new ExpandableQuery<TElement>(this, _previousProvider.CreateQuery<TElement>(expression)); }
IQueryable <T> IQueryProvider.CreateQuery <T>(System.Linq.Expressions.Expression expression) { IQueryable <T> query = m_provider.CreateQuery <T>(expression); TypeInfo t = typeof(T).GetTypeInfo(); if (t.IsInterface || t.IsSubclassOf(basetype)) { return(new WayQueryable <T>(query)); } else { return(query); } }
public IQueryable CreateQuery(Expression expression) { Type elementType = TypeSystem.GetElementType(expression.Type); try { return((IQueryable)Activator.CreateInstance( typeof(ReplicatedTableQuery <>).MakeGenericType(elementType), new object[] { innerQueryProvider.CreateQuery(expression), isConvertMode })); } catch (TargetInvocationException tie) { throw tie.InnerException; } }
static Task <int> InvokeCountAsync(MethodInfo method, IQueryProvider provider, Expression expr, CancellationToken cancellationToken) { var countArgument = ((MethodCallExpression)expr).Arguments[0]; var query = provider.CreateQuery(countArgument); return((Task <int>)InvokeQueryExtensionMethod(method, query.ElementType, query, cancellationToken)); }
public static ObjectQuery GetObjectQuery <TEntity>(DbContext context, IQueryable query) where TEntity : class { if (query is ObjectQuery) { return(query as ObjectQuery); } if (context == null) { throw new ArgumentException("Paramter cannot be null", "context"); } // Use the DbContext to create the ObjectContext ObjectContext objectContext = ((IObjectContextAdapter)context).ObjectContext; // Use the DbSet to create the ObjectSet and get the appropriate provider. IQueryable iqueryable = objectContext.CreateObjectSet <TEntity>() as IQueryable; IQueryProvider provider = iqueryable.Provider; // Use the provider and expression to create the ObjectQuery. return(provider.CreateQuery(query.Expression) as ObjectQuery); }
public IQueryable CreateQuery(Expression expression) { var x = sourceProvider.CreateQuery(expression); IQueryable <T> y = x as IQueryable <T>; return(new DataTablesQueryable <T>(y, request)); }
IQueryProvider IQueryable.Provider => this; // we're going to be our own provider, so we can directly use T IQueryable IQueryProvider.CreateQuery(Expression expression) { // defer all the logic here to the tail, and re-wrap IQueryProvider provider = Tail.Provider; return(Wrap((Query)provider.CreateQuery(expression))); }
IQueryable <TElement> IQueryProvider.CreateQuery <TElement>(Expression expression) { // defer all the logic here to the tail, and re-wrap IQueryProvider provider = Tail.Provider; return((IQueryable <TElement>)Wrap((Query)provider.CreateQuery <TElement>(expression))); }
public void BreakQueryableChain() { var stack = new Stack <MethodCallExpression>(); while (Expr is MethodCallExpression call && call.Method.DeclaringType == typeof(Queryable)) { stack.Push(call); Expr = call.Arguments[0]; } while (stack.Count > 0) { var origCall = stack.Pop(); var newCall = Expression.Call(origCall.Method, new List <Expression>(origCall.Arguments) { [0] = Expr }); if (stack.Count > 0) { var query = Provider.CreateQuery(newCall); Provider = query.Provider; Expr = Expression.Constant(query); } else { Expr = newCall; } } }
protected override Expression VisitMethodCall(MethodCallExpression node) { ExpandableQueryMethodAttribute attrib = (ExpandableQueryMethodAttribute)node.Method.GetCustomAttributes(typeof(ExpandableQueryMethodAttribute), false).FirstOrDefault(); if (attrib != null && node.Method.IsStatic) { if (attrib.TranslationExpression != null && attrib.TranslationExpression.Parameters.Count == node.Arguments.Count) { Dictionary <ParameterExpression, Expression> subDict = new Dictionary <ParameterExpression, Expression>(); for (int i = 0; i < attrib.TranslationExpression.Parameters.Count; i++) { subDict.Add(attrib.TranslationExpression.Parameters[i], node.Arguments[i]); } ExpandingVisitor expander = new ExpandingVisitor(subDict); Expression exp = expander.Visit(attrib.TranslationExpression.Body); return(exp); } else if (typeof(IQueryable).IsAssignableFrom(node.Method.ReturnType)) { object[] args = new object[node.Arguments.Count]; args[0] = _provider.CreateQuery(node.Arguments[0]); for (int i = 1; i < node.Arguments.Count; i++) { Expression arg = node.Arguments[i]; args[i] = (arg.NodeType == ExpressionType.Constant) ? ((ConstantExpression)arg).Value : arg; } Expression exp = ((IQueryable)node.Method.Invoke(null, args)).Expression; return(exp); } } return(base.VisitMethodCall(node)); }
protected override Expression VisitMethodCall(MethodCallExpression node) { bool expandNode = node.Method.GetCustomAttributes(typeof(ExpandableMethodAttribute), false).Any(); if (expandNode && node.Method.IsStatic) { object[] args = new object[node.Arguments.Count]; args[0] = _provider.CreateQuery(node.Arguments[0]); for (int i = 1; i < node.Arguments.Count; i++) { Expression arg = node.Arguments[i]; args[i] = (arg.NodeType == ExpressionType.Constant) ? ((ConstantExpression)arg).Value : arg; } return(((IQueryable)node.Method.Invoke(null, args)).Expression); } var replaceNodeAttributes = node.Method.GetCustomAttributes(typeof(ReplaceInExpressionTree), false).Cast <ReplaceInExpressionTree>(); if (replaceNodeAttributes.Any() && node.Method.IsStatic) { var replaceWith = node.Method.DeclaringType.GetMethod(replaceNodeAttributes.First().MethodName).Invoke(null, null); if (replaceWith is LambdaExpression) { RegisterReplacementParameters(node.Arguments.ToArray(), replaceWith as LambdaExpression); return(Visit((replaceWith as LambdaExpression).Body)); } } return(base.VisitMethodCall(node)); }
public static List <Models.Band <long> > Bands(SizeUpContext context, long variableId, long boundingGeographicLocationId, int bands, Granularity granularity) { var variable = Variables(context).Where(i => i.Id == variableId).Select(i => i.Variable).FirstOrDefault(); var gran = Enum.GetName(typeof(Granularity), granularity); var data = Get(context) .Where(i => i.GeographicLocation.Granularity.Name == gran) .Where(i => i.GeographicLocation.GeographicLocations.Any(g => g.Id == boundingGeographicLocationId)); ConstantExpression constant = Expression.Constant(data); //empty set Type dataType = typeof(ConsumerExpenditure); IQueryProvider provider = data.Provider; var param = Expression.Parameter(dataType, "c"); var selector = Expression.Convert(Expression.Property(param, dataType.GetProperty(variable)), typeof(long?)) as Expression; var pred = Expression.Lambda(selector, param) as Expression; var expression = Expression.Call(typeof(Queryable), "Select", new Type[] { dataType, typeof(long?) }, constant, pred); var output = provider.CreateQuery <long?>(expression) .Where(i => i != null) .ToList() .NTileDescending(i => i, bands) .Select(i => new Band <long>() { Min = i.Min(v => v.Value), Max = i.Max(v => v.Value) }) .ToList(); output.FormatDescending(); return(output); }
public IEnumerator <TElement> ExecuteQuery <TElement>( Expression expression) { return(_underlyingProvider.CreateQuery <TElement>( InterceptExpr(expression) ).GetEnumerator()); }
public void CreateQueryInvalidTypeNonGeneric() { var exp = Expression.Constant(Math.PI); IQueryProvider provider = Enumerable.Empty <string>().AsQueryable().Provider; AssertExtensions.Throws <ArgumentException>(null, () => provider.CreateQuery(exp)); }
public void CreateQueryInvalidType() { var exp = Expression.Constant(Math.PI); IQueryProvider provider = Enumerable.Empty <string>().AsQueryable().Provider; Assert.Throws <ArgumentException>(() => provider.CreateQuery <int>(exp)); }
public void CreateQuery() { var exp = Expression.Constant(Enumerable.Range(3, 4).AsNaturalQueryable()); IQueryProvider provider = Enumerable.Empty <string>().AsNaturalQueryable().Provider; IQueryable <int> query = provider.CreateQuery <int>(exp); Assert.Equal(Enumerable.Range(3, 4), query.AsEnumerable()); }
public void CreateQueryNonGeneric() { var exp = Expression.Constant(Enumerable.Range(3, 4).AsQueryable()); IQueryProvider provider = Enumerable.Empty <string>().AsQueryable().Provider; IQueryable query = provider.CreateQuery(exp); Assert.Equal(Enumerable.Range(3, 4), query.Cast <int>()); }
internal IEnumerator <TElement> ExecuteQuery <TElement>(Expression expression) { var processExpression = this.ProcessExpression(expression); return(_underlyingProvider .CreateQuery <TElement>(processExpression) .GetEnumerator()); }
/// <summary> /// Execute the expression /// </summary> /// <param name="expression">The expression</param> /// <returns>The result</returns> public object Execute(Expression expression) { Expression parameterizedExpression = new EFParameterizedExpressionVisitor().Parameterize(expression); if (typeof(IQueryable).IsAssignableFrom(expression.Type)) { return(underlyingQueryProvider.CreateQuery(parameterizedExpression)); } return(underlyingQueryProvider.Execute(parameterizedExpression)); }
public static IQueryable <TEntity> Include <TEntity, TProperty>(this IQueryable <TEntity> source, Expression <Func <TEntity, TProperty> > navigationPropertyPath) where TEntity : class { source = Unwrap(source, out bool isWrapped, out Type[] args); source = Context.Include(source, navigationPropertyPath); if (isWrapped) { IQueryProvider provider = (IQueryProvider)Activator.CreateInstance(typeof(WrappedQueryableProvider <,>).MakeGenericType(args), source.Provider); source = provider.CreateQuery <TEntity>(source.Expression); } return(source); }