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