public override IQueryState Accept(SkipExpression exp)
{
GeneralQueryState subQueryState = this.AsSubQueryState();
SkipQueryState state = new SkipQueryState(subQueryState.Result, exp.Count);
return(state);
}
public override IQueryState Visit(SkipExpression exp)
{
IQueryState prevState = exp.PrevExpression.Accept(this);
IQueryState state = prevState.Accept(exp);
return(state);
}
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 void SkipExpression_WithSpecifiedSkipNumber_ReturnsCorrectEnumerableWithOffsetCount(int skip)
{
var query = Enumerable.Range(0, 100).AsQueryable();
int range = query.Count() - skip;
var skipExpr = new SkipExpression<int>(skip);
Assert.Equal(range, skipExpr.Map(query).Count());
}
internal Expression VisitSkip(SkipExpression node)
{
if (this.Model.Offset.HasValue)
{
return(node); // LIFO behavior
}
this.Model.Offset = node.Value;
return(node);
}
public override IQueryState Accept(SkipExpression exp)
{
if (exp.Count < 1)
{
return this;
}
this.Count += this.Count;
return this;
}
public IContentQuery <T> Skip(int count)
{
var expression = new SkipExpression(this.Expression, count);
//
if (this is TextContentQuery)
{
expression.OQueryExpression = OQuery
.From((this as TextContentQuery).Schema.Name)
.Skip(count);
}
return(this.Create(expression));
}
public void SkipExpression_ToString_StartsWithSkipPrefix()
{
var skipExpr = new SkipExpression<TestClass>(5);
Assert.True(skipExpr.ToString().StartsWith(ParserConstants.SkipIndicator));
}
public void SkipExpression_ToString_ContainsSkipValue()
{
int skipValue = 2003;
var skipExpr = new SkipExpression<TestClass>(skipValue);
Assert.Contains(skipValue.ToString(), skipExpr.ToString());
}
public IQuery <T> Skip(int count)
{
SkipExpression e = new SkipExpression(typeof(T), this._expression, count);
return(new Query <T>(this._dbContext, e, this._trackEntity));
}
public override JoinQueryResult Visit(SkipExpression exp)
{
JoinQueryResult ret = this.Visit(exp);
return(ret);
}
private string Skip(SkipExpression exp) => $"SELECT * FROM ({Serialize(exp.Sub)}) AS this ORDER BY {Secondary.Serialize(exp.KeySelector.Body)} OFFSET {exp.Count} ROWS";
public IContentQuery <T> Skip(int count)
{
var expression = new SkipExpression(this.Expression, count);
return(this.Create(expression));
}
private void TranslateSkip(SkipExpression node)
{
Translate(node.Source);
_stages.Add(new BsonDocument("$skip", (int)((ConstantExpression)node.Count).Value));
}
private BsonValue TranslateSkip(SkipExpression node)
{
var message = "$project or $group only supports Skip when immediately followed by a Take.";
throw new NotSupportedException(message);
}
protected internal Expression VisitSkip(SkipExpression node)
{
Model.Skip = node.Value;
return node;
}
private void VisitSkip(SkipExpression node)
{
Visit(node.Source);
_stages.Add(new BsonDocument("$skip", node.Count));
}
//public virtual void ReverseOrder()
//{
// this.orderFields.Reverse();
//}
protected abstract void VisitSkip(SkipExpression expression);
public virtual IQueryState Accept(SkipExpression exp)
{
SkipQueryState state = new SkipQueryState(this.Result, exp.Count);
return(state);
}
public virtual IQueryState Accept(SkipExpression exp)
{
SkipQueryState state = new SkipQueryState(this.Result, exp.Count);
return state;
}
