private string Base(Expression exp)
{
var cached = (CachedExpression)exp;
if (cached.Sql != null)
{
return(cached.Sql);
}
cached.Sql = exp switch
{
UnionExpression e => Union(e),
SelectExpression e => Select(e),
WhereExpression e => Where(e),
MaxExpression e => Max(e),
MinExpression e => Min(e),
SumExpression e => Sum(e),
CountExpression e => Count(e),
TakeExpression e => Take(e),
SkipExpression e => Skip(e),
FirstExpression e => First(e),
DistinctExpression e => Distinct(e),
OrderByExpression e => OrderBy(e),
OrderByDescendingExpression e => OrderByDescending(e),
_ => throw new InvalidEnumArgumentException()
};
return(cached.Sql);
}
public override IQueryState Accept(TakeExpression exp)
{
if (exp.Count < this.TakeCount)
this.TakeCount = exp.Count;
return this;
}
public override IQueryState Accept(TakeExpression exp)
{
GeneralQueryState subQueryState = this.AsSubQueryState();
TakeQueryState state = new TakeQueryState(subQueryState.Result, exp.Count);
return(state);
}
public override IQueryState Visit(TakeExpression exp)
{
IQueryState prevState = exp.PrevExpression.Accept(this);
IQueryState state = prevState.Accept(exp);
return(state);
}
public void TakeExpression_SpecifiedTakeNumber_MapReturnsQueriableWithCountEqualToTake(int take)
{
var init = Enumerable.Range(0, 100).AsQueryable();
var takeExpr = new TakeExpression<int>(take);
Assert.Equal(take, takeExpr.Map(init).Count());
}
public override IQueryState Accept(TakeExpression exp)
{
if (exp.Count < this.TakeCount)
{
this.TakeCount = exp.Count;
}
return(this);
}
public IContentQuery <T> Take(int count)
{
var expression = new TakeExpression(this.Expression, count);
//
if (this is TextContentQuery)
{
expression.OQueryExpression = OQuery
.From((this as TextContentQuery).Schema.Name)
.Take(count);
}
return(this.Create(expression));
}
public Expression Bind(PipelineExpression pipeline, PipelineBindingContext bindingContext, MethodCallExpression node, IEnumerable <Expression> arguments)
{
var source = pipeline.Source;
if (arguments.Any())
{
source = BinderHelper.BindWhere(
pipeline,
bindingContext,
ExpressionHelper.GetLambda(arguments.Single()));
}
source = new TakeExpression(source, Expression.Constant(1));
return(new PipelineExpression(
source,
pipeline.Projector,
new AnyResultOperator()));
}
private BsonValue TranslateTake(TakeExpression node)
{
var arguments = new BsonArray();
var skipNode = node.Source as SkipExpression;
if (skipNode != null)
{
arguments.Add(TranslateValue(skipNode.Source));
arguments.Add(TranslateValue(skipNode.Count));
}
else
{
arguments.Add(TranslateValue(node.Source));
}
arguments.Add(TranslateValue(node.Count));
return(new BsonDocument("$slice", arguments));
}
public override Expression Bind(ProjectionExpression projection, ProjectionBindingContext context, MethodCallExpression node, IEnumerable <Expression> arguments)
{
var aggregator = CreateAggregator(node.Method.Name, projection.Projector.Type);
var source = projection.Source;
var argument = arguments.FirstOrDefault();
if (argument != null && ExtensionExpressionVisitor.IsLambda(argument))
{
source = BindPredicate(projection, context, source, argument);
}
source = new TakeExpression(source, 2);
return(new ProjectionExpression(
source,
projection.Projector,
aggregator));
}
public Expression Bind(PipelineExpression pipeline, PipelineBindingContext bindingContext, MethodCallExpression node, IEnumerable <Expression> arguments)
{
var source = pipeline.Source;
if (arguments.Any())
{
source = BinderHelper.BindWhere(
pipeline,
bindingContext,
ExpressionHelper.GetLambda(arguments.Single()));
}
source = new TakeExpression(source, Expression.Constant(1));
return(new PipelineExpression(
source,
pipeline.Projector,
new FirstResultOperator(
pipeline.Projector.Type,
pipeline.Projector.Serializer,
node.Method.Name == nameof(Enumerable.FirstOrDefault))));
}
internal Expression VisitTake(TakeExpression node)
{
if (this.Model.Limit.HasValue)
{
return(node); // LIFO behavior
}
var value = node.Value;
if (value == 0)
{
return(node); // Take(0) is idempotent
}
this.Model.ExecutionPlan.MaxItems = value;
this.Model.Limit = value;
if (value > DefaultApiPageLimit)
{
this.Model.Limit = DefaultApiPageLimit;
}
return(node);
}
public override Expression Bind(ProjectionExpression projection, ProjectionBindingContext context, MethodCallExpression node, IEnumerable <Expression> arguments)
{
LambdaExpression aggregator;
if (node.Method.Name.EndsWith("Async"))
{
aggregator = CreateAsyncAggregator();
}
else
{
aggregator = CreateSyncAggregator();
}
var source = projection.Source;
var argument = arguments.FirstOrDefault();
if (argument != null && ExtensionExpressionVisitor.IsLambda(argument))
{
source = BindPredicate(projection, context, source, argument);
}
source = new TakeExpression(source, 1);
var serializer = context.SerializerRegistry.GetSerializer(typeof(int));
var accumulator = new AccumulatorExpression(typeof(int), AccumulatorType.Count, null);
var serializationAccumulator = new SerializationExpression(
accumulator,
new BsonSerializationInfo("__agg0", serializer, serializer.ValueType));
var rootAccumulator = new RootAccumulatorExpression(source, serializationAccumulator);
return(new ProjectionExpression(
rootAccumulator,
serializationAccumulator,
aggregator));
}
protected abstract void VisitTake(TakeExpression expression);
public IQuery <T> Take(int count)
{
TakeExpression e = new TakeExpression(typeof(T), this._expression, count);
return(new Query <T>(this._dbContext, e, this._trackEntity));
}
public override JoinQueryResult Visit(TakeExpression exp)
{
JoinQueryResult ret = this.Visit(exp);
return(ret);
}
public void TakeExpression_ToString_StartsWithTakeIndicator()
{
var takeExpr = new TakeExpression<int>(3);
Assert.True(takeExpr.ToString().StartsWith(ParserConstants.TakeIndicator));
}
public void TakeExpression_ToString_EndsWithTakeValue()
{
int takeVal = 29;
var takeExpr = new TakeExpression<int>(takeVal);
Assert.True(takeVal.ToString().EndsWith(takeVal.ToString()));
}
public IContentQuery <T> Take(int count)
{
var expression = new TakeExpression(this.Expression, count);
return(this.Create(expression));
}
private string Take(TakeExpression exp) => $"SELECT TOP({exp.Count}) * FROM ({Serialize(exp.Sub)}) AS this";
public virtual IQueryState Accept(TakeExpression exp)
{
TakeQueryState state = new TakeQueryState(this.Result, exp.Count);
return state;
}
public virtual IQueryState Accept(TakeExpression exp)
{
TakeQueryState state = new TakeQueryState(this.Result, exp.Count);
return(state);
}
protected override void VisitTake(TakeExpression expression)
{
query.TakeCount = expression.Count;
}
private void TranslateTake(TakeExpression node)
{
Translate(node.Source);
_stages.Add(new BsonDocument("$limit", (int)((ConstantExpression)node.Count).Value));
}
private void VisitTake(TakeExpression node)
{
Visit(node.Source);
_stages.Add(new BsonDocument("$limit", node.Count));
}
public override IQueryState Accept(TakeExpression exp)
{
var state = new LimitQueryState(this.QueryModel, this.Count, exp.Count);
return(state);
}
public override IQueryState Accept(TakeExpression exp)
{
var state = new LimitQueryState(this.Result, this.Count, exp.Count);
return state;
}
