/// <summary>
/// Apply the filter query to the given IQueryable.
/// </summary>
/// <remarks>
/// The <see cref="ODataQuerySettings.HandleNullPropagation"/> property specifies
/// how this method should handle null propagation.
/// </remarks>
/// <param name="query">The original <see cref="IQueryable"/>.</param>
/// <param name="querySettings">The <see cref="ODataQuerySettings"/> that contains all the query application related settings.</param>
/// <returns>The new <see cref="IQueryable"/> after the filter query has been applied to.</returns>
public IQueryable ApplyTo(IQueryable query, ODataQuerySettings querySettings)
{
if (query == null)
{
throw Error.ArgumentNull("query");
}
if (querySettings == null)
{
throw Error.ArgumentNull("querySettings");
}
if (Context.ElementClrType == null)
{
throw Error.NotSupported(SRResources.ApplyToOnUntypedQueryOption, "ApplyTo");
}
FilterClause filterClause = FilterClause;
Contract.Assert(filterClause != null);
ODataQuerySettings updatedSettings = Context.UpdateQuerySettings(querySettings, query);
Expression filter = FilterBinder.Bind(query, filterClause, Context.ElementClrType, Context, updatedSettings);
query = ExpressionHelpers.Where(query, filter, Context.ElementClrType);
return(query);
}
/// <summary>
/// Apply the apply query to the given IQueryable.
/// </summary>
/// <remarks>
/// The <see cref="ODataQuerySettings.HandleNullPropagation"/> property specifies
/// how this method should handle null propagation.
/// </remarks>
/// <param name="query">The original <see cref="IQueryable"/>.</param>
/// <param name="querySettings">The <see cref="ODataQuerySettings"/> that contains all the query application related settings.</param>
/// <param name="assemblyProvider">The <see cref="IAssemblyProvider"/> to use.</param>
/// <returns>The new <see cref="IQueryable"/> after the filter query has been applied to.</returns>
public IQueryable ApplyTo(IQueryable query, ODataQuerySettings querySettings, IAssemblyProvider assemblyProvider)
{
if (query == null)
{
throw Error.ArgumentNull("query");
}
if (querySettings == null)
{
throw Error.ArgumentNull("querySettings");
}
if (assemblyProvider == null)
{
throw Error.ArgumentNull("assemblyProvider");
}
if (Context.ElementClrType == null)
{
throw Error.NotSupported(SRResources.ApplyToOnUntypedQueryOption, "ApplyTo");
}
ApplyClause applyClause = ApplyClause;
Contract.Assert(applyClause != null);
// Ensure we have decided how to handle null propagation
ODataQuerySettings updatedSettings = querySettings;
if (querySettings.HandleNullPropagation == HandleNullPropagationOption.Default)
{
updatedSettings = new ODataQuerySettings(updatedSettings);
updatedSettings.HandleNullPropagation = HandleNullPropagationOptionHelper.GetDefaultHandleNullPropagationOption(query);
}
foreach (var transformation in applyClause.Transformations)
{
if (transformation.Kind == TransformationNodeKind.Aggregate || transformation.Kind == TransformationNodeKind.GroupBy)
{
var binder = new AggregationBinder(updatedSettings, assemblyProvider, ResultClrType, Context.Model, transformation as TransformationNode, _serviceProvider);
query = binder.Bind(query);
this.ResultClrType = binder.ResultClrType;
}
else if (transformation.Kind == TransformationNodeKind.Filter)
{
var filterTransformation = transformation as FilterTransformationNode;
Expression filter = FilterBinder.Bind(filterTransformation.FilterClause, ResultClrType, Context.Model, assemblyProvider, updatedSettings, _serviceProvider);
query = ExpressionHelpers.Where(query, filter, ResultClrType);
}
}
return(query);
}
/// <summary>
/// Apply the filter query to the given IQueryable.
/// </summary>
/// <remarks>
/// The <see cref="ODataQuerySettings.HandleNullPropagation"/> property specifies
/// how this method should handle null propagation.
/// </remarks>
/// <param name="query">The original <see cref="IQueryable"/>.</param>
/// <param name="querySettings">The <see cref="ODataQuerySettings"/> that contains all the query application related settings.</param>
/// <param name="assembliesResolver">The assembly to use.</param>
/// <returns>The new <see cref="IQueryable"/> after the filter query has been applied to.</returns>
public IQueryable ApplyTo(IQueryable query, ODataQuerySettings querySettings, AssembliesResolver assembliesResolver)
{
if (query == null)
{
throw Error.ArgumentNull("query");
}
if (assembliesResolver == null)
{
throw Error.ArgumentNull("AssembliesResolver");
}
if (Context.ElementClrType == null)
{
throw Error.NotSupported(SRResources.ApplyToOnUntypedQueryOption, "ApplyTo");
}
var filter = FilterBinder.Bind(FilterClause, Context.ElementClrType, Context.Model, assembliesResolver, querySettings);
return(ExpressionHelpers.Where(query, filter, Context.ElementClrType));
}
/// <summary>
/// Apply the ETag to the given IQueryable.
/// </summary>
/// <param name="query">The original <see cref="IQueryable"/>.</param>
/// <returns>The new <see cref="IQueryable"/> after the ETag has been applied to.</returns>
public virtual IQueryable ApplyTo(IQueryable query)
{
if (IsAny)
{
return(query);
}
Type type = EntityType;
ParameterExpression param = Expression.Parameter(type);
Expression where = null;
foreach (KeyValuePair <string, object> item in ConcurrencyProperties)
{
MemberExpression name = Expression.Property(param, item.Key);
object itemValue = item.Value;
Expression value = itemValue != null
? LinqParameterContainer.Parameterize(itemValue.GetType(), itemValue)
: Expression.Constant(value: null);
BinaryExpression equal = Expression.Equal(name, value);
where = where == null ? equal : Expression.AndAlso(where, equal);
}
if (where == null)
{
return(query);
}
if (IsIfNoneMatch)
{
where = Expression.Not(where);
}
Expression whereLambda = Expression.Lambda(where, param);
return(ExpressionHelpers.Where(query, whereLambda, type));
}
/// <summary>
/// Apply the apply query to the given IQueryable.
/// </summary>
/// <remarks>
/// The <see cref="ODataQuerySettings.HandleNullPropagation"/> property specifies
/// how this method should handle null propagation.
/// </remarks>
/// <param name="query">The original <see cref="IQueryable"/>.</param>
/// <param name="querySettings">The <see cref="ODataQuerySettings"/> that contains all the query application related settings.</param>
/// <returns>The new <see cref="IQueryable"/> after the filter query has been applied to.</returns>
public IQueryable ApplyTo(IQueryable query, ODataQuerySettings querySettings)
{
if (query == null)
{
throw Error.ArgumentNull("query");
}
if (querySettings == null)
{
throw Error.ArgumentNull("querySettings");
}
if (Context.ElementClrType == null)
{
throw Error.NotSupported(SRResources.ApplyToOnUntypedQueryOption, "ApplyTo");
}
// Linq to SQL not supported for $apply
if (query.Provider.GetType().Namespace == HandleNullPropagationOptionHelper.Linq2SqlQueryProviderNamespace)
{
throw Error.NotSupported(SRResources.ApplyQueryOptionNotSupportedForLinq2SQL);
}
ApplyClause applyClause = ApplyClause;
Contract.Assert(applyClause != null);
ODataQuerySettings updatedSettings = Context.UpdateQuerySettings(querySettings, query);
// The IWebApiAssembliesResolver service is internal and can only be injected by WebApi.
// This code path may be used in cases when the service container is not available
// and the service container is available but may not contain an instance of IWebApiAssembliesResolver.
IAssemblyResolver assembliesResolver = AssemblyResolverHelper.Default;
if (Context.RequestContainer != null)
{
IAssemblyResolver injectedResolver = Context.RequestContainer.GetService <IAssemblyResolver>();
if (injectedResolver != null)
{
assembliesResolver = injectedResolver;
}
}
foreach (var transformation in applyClause.Transformations)
{
if (transformation.Kind == TransformationNodeKind.Aggregate || transformation.Kind == TransformationNodeKind.GroupBy)
{
var binder = new AggregationBinder(updatedSettings, assembliesResolver, ResultClrType, Context.Model, transformation);
query = binder.Bind(query);
this.ResultClrType = binder.ResultClrType;
}
else if (transformation.Kind == TransformationNodeKind.Compute)
{
var binder = new ComputeBinder(updatedSettings, assembliesResolver, ResultClrType, Context.Model, (ComputeTransformationNode)transformation);
query = binder.Bind(query);
this.ResultClrType = binder.ResultClrType;
}
else if (transformation.Kind == TransformationNodeKind.Filter)
{
var filterTransformation = transformation as FilterTransformationNode;
Expression filter = FilterBinder.Bind(query, filterTransformation.FilterClause, ResultClrType, Context, querySettings);
query = ExpressionHelpers.Where(query, filter, ResultClrType);
}
}
return(query);
}
/// <summary>
/// Core logic for applying the query option to the IQueryable.
/// </summary>
/// <param name="query">The original <see cref="IQueryable"/>.</param>
/// <param name="querySettings">Query setting used for validating the query option.</param>
/// <param name="orderByNodes">OrderBy information required to correctly apply the query option for default implementation.</param>
/// <param name="context">The <see cref="ODataQueryContext"/> which contains the <see cref="IEdmModel"/> and some type information</param>
/// <param name="skipTokenRawValue">The raw string value of the skiptoken query parameter.</param>
/// <returns></returns>
private static IQueryable ApplyToCore(IQueryable query, ODataQuerySettings querySettings, IList <OrderByNode> orderByNodes, ODataQueryContext context, string skipTokenRawValue)
{
if (query == null)
{
throw Error.ArgumentNull(nameof(query));
}
if (context.ElementClrType == null)
{
throw Error.NotSupported(SRResources.ApplyToOnUntypedQueryOption, "ApplyTo");
}
IDictionary <string, OrderByDirection> directionMap;
if (orderByNodes != null)
{
directionMap =
orderByNodes.OfType <OrderByPropertyNode>().ToDictionary(node => node.Property.Name, node => node.Direction);
}
else
{
directionMap = new Dictionary <string, OrderByDirection>();
}
IDictionary <string, object> propertyValuePairs = PopulatePropertyValuePairs(skipTokenRawValue, context);
if (propertyValuePairs.Count == 0)
{
throw Error.InvalidOperation("Unable to get property values from the skiptoken value.");
}
ExpressionBinderBase binder = context.GetFilterBinder(querySettings);
bool parameterizeConstant = querySettings.EnableConstantParameterization;
ParameterExpression param = Expression.Parameter(context.ElementClrType);
Expression where = null;
/* We will create a where lambda of the following form -
* Where (Prop1>Value1)
* OR (Prop1=Value1 AND Prop2>Value2)
* OR (Prop1=Value1 AND Prop2=Value2 AND Prop3>Value3)
* and so on...
* Adding the first true to simplify implementation.
*/
Expression lastEquality = null;
bool firstProperty = true;
foreach (KeyValuePair <string, object> item in propertyValuePairs)
{
string key = item.Key;
MemberExpression property = Expression.Property(param, key);
object value = item.Value;
Expression compare = null;
ODataEnumValue enumValue = value as ODataEnumValue;
if (enumValue != null)
{
value = enumValue.Value;
}
Expression constant = parameterizeConstant ? LinqParameterContainer.Parameterize(value.GetType(), value) : Expression.Constant(value);
if (directionMap.ContainsKey(key) && directionMap[key] == OrderByDirection.Descending)
{
compare = binder.CreateBinaryExpression(BinaryOperatorKind.LessThan, property, constant, true);
}
else
{
compare = binder.CreateBinaryExpression(BinaryOperatorKind.GreaterThan, property, constant, true);
}
if (firstProperty)
{
lastEquality = binder.CreateBinaryExpression(BinaryOperatorKind.Equal, property, constant, true);
where = compare;
firstProperty = false;
}
else
{
Expression condition = Expression.AndAlso(lastEquality, compare);
where = Expression.OrElse(where, condition);
lastEquality = Expression.AndAlso(lastEquality, binder.CreateBinaryExpression(BinaryOperatorKind.Equal, property, constant, true));
}
}
Expression whereLambda = Expression.Lambda(where, param);
return(ExpressionHelpers.Where(query, whereLambda, query.ElementType));
}