public ODataQuery Create()
{
return(new ODataQuery
{
FormatPredicate = ODataQueryPart.Format(ODataFormat.Json)
});
}
protected override OrderByQueryPart Parse(string parameterValue)
{
// TODO: support complex order by expressions (e.g. "$orderby=(Id mod 3) desc")
var matches = Regex.Matches(parameterValue, @"(\w+)\s+(asc|desc)", RegexOptions.IgnoreCase).Cast <Match>();
var orderings = new List <ODataOrdering>();
foreach (var match in matches)
{
var groups = match.Groups.Cast <Group>().Skip(1).ToList();
var property = groups[0].Value;
var dir = groups[1].Value;
ODataOrderingDirection direction;
if (Enum.TryParse(dir, true, out direction) == false)
{
// TODO: I'm pretty sure this branch will never be taken, but...
throw new ArgumentException(String.Format("'{0}' is not a valid ordering direction.", dir));
}
orderings.Add(ODataQueryPart.Ordering(property, direction));
}
return(ODataQueryPart.OrderBy(orderings.ToArray()));
}
public override void VisitResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, int index)
{
// Remotion.Linq.Clauses.ResultOperators.AggregateFromSeedResultOperator
// Remotion.Linq.Clauses.ResultOperators.AggregateResultOperator
// Remotion.Linq.Clauses.ResultOperators.AllResultOperator
// Remotion.Linq.Clauses.ResultOperators.AnyResultOperator
// Remotion.Linq.Clauses.ResultOperators.AverageResultOperator
// Remotion.Linq.Clauses.ResultOperators.CastResultOperator
// Remotion.Linq.Clauses.ResultOperators.ChoiceResultOperatorBase
// Remotion.Linq.Clauses.ResultOperators.ContainsResultOperator
// Remotion.Linq.Clauses.ResultOperators.CountResultOperator
// Remotion.Linq.Clauses.ResultOperators.DefaultIfEmptyResultOperator
// Remotion.Linq.Clauses.ResultOperators.DistinctResultOperator
// Remotion.Linq.Clauses.ResultOperators.ExceptResultOperator
// Remotion.Linq.Clauses.ResultOperators.FirstResultOperator
// Remotion.Linq.Clauses.ResultOperators.GroupResultOperator
// Remotion.Linq.Clauses.ResultOperators.IntersectResultOperator
// Remotion.Linq.Clauses.ResultOperators.LastResultOperator
// Remotion.Linq.Clauses.ResultOperators.LongCountResultOperator
// Remotion.Linq.Clauses.ResultOperators.MaxResultOperator
// Remotion.Linq.Clauses.ResultOperators.MinResultOperator
// Remotion.Linq.Clauses.ResultOperators.OfTypeResultOperator
// Remotion.Linq.Clauses.ResultOperators.ReverseResultOperator
// Remotion.Linq.Clauses.ResultOperators.SequenceFromSequenceResultOperatorBase
// Remotion.Linq.Clauses.ResultOperators.SequenceTypePreservingResultOperatorBase
// Remotion.Linq.Clauses.ResultOperators.SingleResultOperator
// Remotion.Linq.Clauses.ResultOperators.SkipResultOperator
// Remotion.Linq.Clauses.ResultOperators.SumResultOperator
// Remotion.Linq.Clauses.ResultOperators.TakeResultOperator
// Remotion.Linq.Clauses.ResultOperators.UnionResultOperator
// Remotion.Linq.Clauses.ResultOperators.ValueFromSequenceResultOperatorBase
if (resultOperator is CountResultOperator)
{
_query.CountPredicate = ODataQueryPart.Count();
}
else if (resultOperator is LongCountResultOperator)
{
_query.CountPredicate = ODataQueryPart.Count();
}
else if (resultOperator is SkipResultOperator)
{
var skipOperator = (SkipResultOperator)resultOperator;
var skipCount = skipOperator.GetConstantCount();
_query.SkipPredicate = ODataQueryPart.Skip(skipCount);
}
else if (resultOperator is TakeResultOperator)
{
var takeOperator = (TakeResultOperator)resultOperator;
var takeCount = takeOperator.GetConstantCount();
_query.TopPredicate = ODataQueryPart.Top(takeCount);
}
base.VisitResultOperator(resultOperator, queryModel, index);
}
public override void VisitWhereClause(WhereClause whereClause, QueryModel queryModel, int index)
{
// the predicate here is not a lambda; it is just the body of the Where() lambda
var oDataFilterExpression = _filterExpressionTranslator.Translate(whereClause.Predicate);
_query.FilterPredicate = ODataQueryPart.Filter(oDataFilterExpression);
base.VisitWhereClause(whereClause, queryModel, index);
}
protected override InlineCountQueryPart Parse(string parameterValue)
{
InlineCountType countType;
if (Enum.TryParse(parameterValue, true, out countType) == false)
{
throw new ArgumentException(String.Format("'{0}' not recognized as an inline count type.", parameterValue));
}
return(ODataQueryPart.InlineCount(countType));
}
protected override TopQueryPart Parse(string parameterValue)
{
int count;
if (Int32.TryParse(parameterValue, out count) == false)
{
throw new ArgumentException(String.Format("Cannot take the top '{0}' number of items. '{0}' is not an integar.", parameterValue));
}
return(ODataQueryPart.Top(count));
}
protected override FormatQueryPart Parse(string parameterValue)
{
ODataFormat format;
if (Enum.TryParse(parameterValue, true, out format) == false)
{
throw new ArgumentException(String.Format("'{0}' is not a recognized OData format specification.", parameterValue));
}
return(ODataQueryPart.Format(format));
}
protected override FilterQueryPart Parse(string parameterValue)
{
var tokens = _regularExpressionTableLexer.Tokenize(parameterValue);
var result = ShuntingYardAlgorithm(tokens);
var builderStrategy = new FilterExpressionParserStrategy();
var filterExpression = builderStrategy.BuildExpression(result);
return(ODataQueryPart.Filter(filterExpression));
}
public void Translate_SkipThree_ReturnsLastThreeResult()
{
var query = new ODataQuery
{
SkipPredicate = ODataQueryPart.Skip(3)
};
var expression = _translator.Translate <TestModel>(query);
var fn = (Func <IQueryable <TestModel>, IQueryable <TestModel> >)expression.Compile();
var result = fn(_source).ToList();
Assert.That(result.Count, Is.EqualTo(3));
Assert.That(result[0].TestInt, Is.EqualTo(6));
Assert.That(result[1].TestInt, Is.EqualTo(7));
Assert.That(result[2].TestInt, Is.EqualTo(8));
}
protected override SelectQueryPart Parse(string parameterValue)
{
var matches = Regex.Matches(parameterValue, @"(?:\w+/)*\w+", RegexOptions.IgnoreCase).Cast <Match>();
var selectors = new List <MemberAccessFilterExpression>();
foreach (var match in matches)
{
var s = match.Value.Split('/');
var selector = s
.Aggregate <string, MemberAccessFilterExpression>(null, FilterExpression.MemberAccess);
selectors.Add(selector);
}
return(ODataQueryPart.Select(selectors.ToArray()));
}
public void Translate_TestIntEqualsThree_ReturnsOneResult()
{
var left = FilterExpression.MemberAccess("TestInt");
var right = FilterExpression.Constant(3);
var filterExpression = FilterExpression.Binary(left, FilterExpressionOperator.Equal, right);
var query = new ODataQuery
{
FilterPredicate = ODataQueryPart.Filter(filterExpression)
};
var expression = _translator.Translate <TestModel>(query);
var fn = (Func <IQueryable <TestModel>, IQueryable <TestModel> >)expression.Compile();
var result = fn(_source).ToList();
Assert.That(result.Count, Is.EqualTo(1));
Assert.That(result[0].TestInt, Is.EqualTo(3));
}
public override void VisitOrdering(Ordering ordering, QueryModel queryModel, OrderByClause orderByClause, int index)
{
if (_query.OrderByPredicate == null)
{
_query.OrderByPredicate = ODataQueryPart.OrderBy();
}
if (ordering.Expression.NodeType == ExpressionType.MemberAccess)
{
var memberExpression = (MemberExpression)ordering.Expression;
var direction = (ordering.OrderingDirection == OrderingDirection.Asc)
? ODataOrderingDirection.Asc
: ODataOrderingDirection.Desc;
var o = ODataQueryPart.Ordering(memberExpression.Member.Name, direction);
_query.OrderByPredicate.AddOrdering(o);
}
base.VisitOrdering(ordering, queryModel, orderByClause, index);
}
protected override SkipTokenQueryPart Parse(string parameterValue)
{
return(ODataQueryPart.SkipToken(parameterValue));
}
protected override CountQueryPart Parse(string parameterValue)
{
return(ODataQueryPart.Count());
}
public override void VisitSelectClause(SelectClause selectClause, QueryModel queryModel)
{
var selectors = new List <string>();
if (selectClause.Selector.NodeType == ExpressionType.MemberAccess)
{
// TODO: handle access of child properties in selector statements
var selector = (MemberExpression)selectClause.Selector;
selectors.Add(selector.Member.Name);
}
else if (selectClause.Selector.NodeType == ExpressionType.New)
{
// TODO: trying to support this may not be viable...
var constructor = (NewExpression)selectClause.Selector;
foreach (var argument in constructor.Arguments)
{
if (argument.NodeType == ExpressionType.MemberAccess)
{
var member = (MemberExpression)argument;
selectors.Add(member.Member.Name);
}
else
{
throw new NotSupportedException("Cannot select non-members from the result set.");
}
}
}
else if (selectClause.Selector.NodeType == ExpressionType.MemberInit)
{
var memberInit = (MemberInitExpression)selectClause.Selector;
var constructor = memberInit.NewExpression;
foreach (var argument in constructor.Arguments)
{
if (argument.NodeType == ExpressionType.MemberAccess)
{
var member = (MemberExpression)argument;
selectors.Add(member.Member.Name);
}
else
{
throw new NotSupportedException("Cannot select non-members from the result set.");
}
}
foreach (var memberBinding in memberInit.Bindings)
{
if (memberBinding.BindingType == MemberBindingType.Assignment)
{
var assignment = (MemberAssignment)memberBinding;
if (assignment.Expression.NodeType == ExpressionType.MemberAccess)
{
var selectedMember = (MemberExpression)assignment.Expression;
if (memberBinding.Member.Name == selectedMember.Member.Name)
{
selectors.Add(selectedMember.Member.Name);
}
else
{
throw new NotSupportedException($"Cannot alias member '{selectedMember.Member.Name}' as '{memberBinding.Member.Name}'. Aliasing projections is not supported in LinqToRest.");
}
}
else
{
throw new NotSupportedException("Cannot select non-members into the result set.");
}
}
else
{
throw new NotSupportedException("Cannot select lists from the result set.");
}
}
}
if (selectors.Any())
{
_query.SelectPredicate = ODataQueryPart.Select(selectors.Distinct().Select(FilterExpression.MemberAccess).ToArray());
}
base.VisitSelectClause(selectClause, queryModel);
}
