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