// <summary>
// <see
// cref="TransformIntersectOrExcept(DbExpression, DbExpression, DbExpressionKind, System.Collections.Generic.IList{System.Data.Entity.Core.Common.CommandTrees.DbPropertyExpression}, string)" />
// Logicaly, <see cref="DbSkipExpression" /> translates to:
// SELECT Y.x1, Y.x2, ..., Y.xn
// FROM (
// SELECT X.x1, X.x2, ..., X.xn,
// FROM input AS X
// EXCEPT
// SELECT TOP(count) Z.x1, Z.x2, ..., Z.xn
// FROM input AS Z
// ORDER BY sk1, sk2, ...
// ) AS Y
// ORDER BY sk1, sk2, ...
// Here, input refers to the input of the <see cref="DbSkipExpression" />, and count to the count property of the
// <see
// cref="DbSkipExpression" />
// .
// The implementation of EXCEPT is non-duplicate eliminating, and does equality comparison only over the
// equality comparable columns of the input.
// This corresponds to the following expression tree:
// SORT
// |
// NON-DISTINCT EXCEPT (specially translated,
// |
// | - Left: clone of input
// | - Right:
// |
// Limit
// |
// | - Limit: Count
// | - Input
// |
// Sort
// |
// input
// </summary>
public override DbExpression Visit(DbSkipExpression e)
{
Check.NotNull(e, "e");
//Build the right input of the except
DbExpression rightInput = VisitExpressionBinding(e.Input).Sort(VisitSortOrder(e.SortOrder)).Limit(VisitExpression(e.Count));
//Build the left input for the except
var leftInput = VisitExpression(e.Input.Expression); //Another copy of the input
var sortOrder = VisitSortOrder(e.SortOrder); //Another copy of the sort order
// Create a list of the sort expressions to be used for translating except
IList <DbPropertyExpression> sortExpressions = new List <DbPropertyExpression>(e.SortOrder.Count);
foreach (var sortClause in sortOrder)
{
//We only care about property expressions, not about constants
if (sortClause.Expression.ExpressionKind
== DbExpressionKind.Property)
{
sortExpressions.Add((DbPropertyExpression)sortClause.Expression);
}
}
var exceptExpression = TransformIntersectOrExcept(
leftInput, rightInput, DbExpressionKind.Skip, sortExpressions, e.Input.VariableName);
DbExpression result = exceptExpression.BindAs(e.Input.VariableName).Sort(sortOrder);
return(result);
}
public override bool Visit(DbSkipExpression expression)
{
VisitExpressionBinding(expression.Input);
VisitSortClauseList(expression.SortOrder);
VisitExpression(expression.Count);
return(true);
}
internal LimitSkipLifter(DbLimitExpression limit, DbSkipExpression skip, AliasGenerator aliasGenerator)
: base(limit, aliasGenerator)
{
_limit = limit;
_skip = skip;
_source = skip.Input.Expression;
}
internal ProjectSkipLifter(DbProjectExpression project, DbSkipExpression skip, AliasGenerator aliasGenerator)
: base(project, aliasGenerator)
{
_project = project;
_skip = skip;
_source = _skip.Input.Expression;
}
public override VfpExpression Visit(DbSkipExpression expression)
{
return(new VfpSkipExpression(expression.ResultType,
CreateDbExpressionBinding(expression.Input),
CreateDbSortClauses(expression.SortOrder),
expression.Count.Accept(this)));
}
/// <summary>
/// For Sql9 it translates to:
/// SELECT Y.x1, Y.x2, ..., Y.xn
/// FROM (
/// SELECT X.x1, X.x2, ..., X.xn, row_number() OVER (ORDER BY sk1, sk2, ...) AS [row_number]
/// FROM input as X
/// ) as Y
/// WHERE Y.[row_number] > count
/// ORDER BY sk1, sk2, ...
/// </summary>
/// <param name="e"></param>
/// <returns>A <see cref="SqlBuilder"/></returns>
public override ISqlFragment Visit(DbSkipExpression e)
{
Debug.Assert(e.Count is DbConstantExpression || e.Count is DbParameterReferenceExpression, "DbSkipExpression.Count is of invalid expression type");
Symbol fromSymbol;
var result = VisitInputExpression(e.Input.Expression, e.Input.VariableName, e.Input.VariableType, out fromSymbol);
// Skip should be compatible with anything
if (!IsCompatible(result, e.ExpressionKind))
{
result = CreateNewSelectStatement(result, e.Input.VariableName, e.Input.VariableType, out fromSymbol);
}
selectStatementStack.Push(result);
symbolTable.EnterScope();
AddFromSymbol(result, e.Input.VariableName, fromSymbol);
AddSortKeys(result.OrderBy, e.SortOrder);
result.Top.SkipCount = HandleCountExpression(e.Count);
symbolTable.ExitScope();
selectStatementStack.Pop();
return(result);
}
public override void Visit(DbSkipExpression e)
{
Begin(e);
Dump(e.Input, "Input");
Dump(e.SortOrder);
Dump(e.Count, "Count");
End(e);
}
protected DbSkipExpression AddToSkip(DbExpression input, DbSkipExpression skip, DbExpression plusK)
{
// source.Skip(k, o).Skip(k2) -> source.Skip(k + k2, o)
DbExpression newCount = CombineIntegers(skip.Count, plusK,
(l, r) => l + r);
return(RebindSkip(input, skip, newCount));
}
public override void Visit(DbSkipExpression e)
{
Check.NotNull <DbSkipExpression>(e, nameof(e));
this.Begin((DbExpression)e);
this.Dump(e.Input, "Input");
this.Dump(e.SortOrder);
this.Dump(e.Count, "Count");
this.End((DbExpression)e);
}
/// <summary>
/// Implements the visitor pattern for <see cref="T:System.Data.Common.CommandTrees.DbSkipExpression"/>.
/// </summary>
/// <param name="expression">The <see cref="T:System.Data.Common.CommandTrees.DbSkipExpression"/> that is visited.</param>
public override void Visit(DbSkipExpression expression)
{
expression.Count.Accept(this);
expression.Input.Expression.Accept(this);
foreach (var sortClause in expression.SortOrder)
{
sortClause.Expression.Accept(this);
}
}
public override void Visit(DbSkipExpression expression)
{
Write(expression);
_depth++;
Write("Input", expression.Input);
Write("Count", expression.Count);
Write("SortOrder", expression.SortOrder);
_depth--;
}
public override TreeNode Visit(DbSkipExpression e)
{
TreeNode retInfo = NodeFromExpression(e);
retInfo.Children.Add(this.VisitBinding("Input", e.Input));
retInfo.Children.Add(this.VisitSortOrder(e.SortOrder));
retInfo.Children.Add(this.Visit("Count", e.Count));
return(retInfo);
}
public override void Visit(DbSkipExpression e)
{
VisitExprKind(e.ExpressionKind);
_key.Append('(');
VisitBinding(e.Input);
VisitSortOrder(e.SortOrder);
_key.Append('(');
e.Count.Accept(this);
_key.Append("))");
}
public override Expression Visit(DbSkipExpression expression)
{
Expression source = this.Visit(expression.Input.Expression);
Type sourceType = TypeHelper.GetElementType(source.Type);
// Skip cannot be used without sorting
Expression result = this.CreateOrderByExpression(expression.SortOrder, expression.Input.VariableName, source);
return queryMethodExpressionBuilder.Skip(result, this.Visit(expression.Count, typeof(int)));
}
public override void Visit(DbSkipExpression e)
{
Check.NotNull(e, "e");
Begin(e);
Dump(e.Input, "Input");
Dump(e.SortOrder);
Dump(e.Count, "Count");
End(e);
}
public override TreeNode Visit(DbSkipExpression e)
{
Check.NotNull <DbSkipExpression>(e, nameof(e));
TreeNode treeNode = ExpressionPrinter.PrinterVisitor.NodeFromExpression((DbExpression)e);
treeNode.Children.Add(this.VisitBinding("Input", e.Input));
treeNode.Children.Add(this.VisitSortOrder(e.SortOrder));
treeNode.Children.Add(this.Visit("Count", e.Count));
return(treeNode);
}
public override Expression Visit(DbSkipExpression expression)
{
Expression source = this.Visit(expression.Input.Expression);
Type sourceType = TypeHelper.GetElementType(source.Type);
// Skip cannot be used without sorting
Expression result = this.CreateOrderByExpression(expression.SortOrder, expression.Input.VariableName, source);
return(queryMethodExpressionBuilder.Skip(result, this.Visit(expression.Count, typeof(int))));
}
public override DbExpression Visit(DbSkipExpression expression)
{
Check.NotNull <DbSkipExpression>(expression, nameof(expression));
DbExpression input = this.Find(expression.Input.Expression);
if (!object.ReferenceEquals((object)input, (object)expression.Input.Expression))
{
return((DbExpression)input.BindAs(expression.Input.VariableName).Skip((IEnumerable <DbSortClause>)expression.SortOrder, expression.Count));
}
return((DbExpression)expression);
}
public override void Visit(DbSkipExpression e)
{
Check.NotNull <DbSkipExpression>(e, nameof(e));
this.VisitExprKind(e.ExpressionKind);
this._key.Append('(');
this.VisitBinding(e.Input);
this.VisitSortOrder(e.SortOrder);
this._key.Append('(');
e.Count.Accept((DbExpressionVisitor)this);
this._key.Append("))");
}
public override void Visit(DbSkipExpression expression)
{
EntityUtils.CheckArgumentNull <DbSkipExpression>(expression, nameof(expression));
this.VisitExpressionBindingPre(expression.Input);
foreach (DbSortClause dbSortClause in (IEnumerable <DbSortClause>)expression.SortOrder)
{
this.VisitExpression(dbSortClause.Expression);
}
this.VisitExpressionBindingPost(expression.Input);
this.VisitExpression(expression.Count);
}
public override TreeNode Visit(DbSkipExpression e)
{
Check.NotNull(e, "e");
var retInfo = NodeFromExpression(e);
retInfo.Children.Add(VisitBinding("Input", e.Input));
retInfo.Children.Add(VisitSortOrder(e.SortOrder));
retInfo.Children.Add(Visit("Count", e.Count));
return(retInfo);
}
public override LegacyCommandTrees.DbExpression Visit(DbSkipExpression expression)
{
Debug.Assert(expression != null, "expression != null");
return
(expression.Input.Expression.Accept(this)
.BindAs(expression.Input.VariableName)
.Skip(
expression.SortOrder.Select(ConvertToLegacySortClause),
expression.Count.Accept(this)));
}
public override bool Visit(DbSkipExpression expression)
{
Check.NotNull <DbSkipExpression>(expression, nameof(expression));
if (expression.Count is DbParameterReferenceExpression)
{
throw new NotSupportedException(Strings.SqlGen_ParameterForSkipNotSupportedOnSql8);
}
this.VisitExpressionBinding(expression.Input);
this.VisitSortClauseList(expression.SortOrder);
this.VisitExpression(expression.Count);
return(true);
}
public override DbExpression Visit(DbSkipExpression expression)
{
DbExpression found = Find(expression.Input.Expression);
if (!object.ReferenceEquals(found, expression.Input.Expression))
{
return(found.BindAs(expression.Input.VariableName).Skip(expression.SortOrder, expression.Count));
}
else
{
return(expression);
}
}
/// <summary>
/// Visitor pattern method for <see cref="DbSkipExpression" />.
/// </summary>
/// <param name="expression"> The DbLimitExpression that is being visited. </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="expression" />
/// is null
/// </exception>
public override void Visit(DbSkipExpression expression)
{
Check.NotNull(expression, "expression");
VisitExpressionBindingPre(expression.Input);
foreach (var s in expression.SortOrder)
{
VisitExpression(s.Expression);
}
VisitExpressionBindingPost(expression.Input);
VisitExpression(expression.Count);
}
/// <summary>
/// Implements the visitor pattern for <see cref="T:System.Data.Common.CommandTrees.DbSkipExpression"/>.
/// </summary>
/// <param name="expression">The <see cref="T:System.Data.Common.CommandTrees.DbSkipExpression"/> that is visited.</param>
public override void Visit(DbSkipExpression expression)
{
if (expression == null)
{
throw new ArgumentNullException("expression");
}
expression.Count.Accept(this);
expression.Input.Expression.Accept(this);
foreach (var sortClause in expression.SortOrder)
{
sortClause.Expression.Accept(this);
}
}
/// <summary>
/// Resturns true
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
/// <exception cref="NotSupportedException">expression.Count is DbParameterReferenceExpression</exception>
public override bool Visit(DbSkipExpression expression)
{
if (expression.Count is DbParameterReferenceExpression)
{
throw EntityUtil.NotSupported(System.Data.Entity.Strings.SqlGen_ParameterForSkipNotSupportedOnSql8);
}
//Walk the structure in case a non-supported construct is encountered
VisitExpressionBinding(expression.Input);
VisitSortClauseList(expression.SortOrder);
VisitExpression(expression.Count);
return(true);
}
/// <summary>
/// Implements the visitor pattern for <see cref="T:System.Data.Common.CommandTrees.DbSkipExpression"/>.
/// </summary>
/// <param name="expression">The <see cref="T:System.Data.Common.CommandTrees.DbSkipExpression"/> that is visited.</param>
public override void Visit(DbSkipExpression expression)
{
if (expression == null)
{
throw new ArgumentNullException("expression");
}
expression.Count.Accept(this);
expression.Input.Expression.Accept(this);
foreach (var sortClause in expression.SortOrder)
{
sortClause.Expression.Accept(this);
}
}
public override void Visit(DbSkipExpression expression)
{
if (expression == null)
{
throw new ArgumentException("expression");
}
VisitExpressionBindingPre(expression.Input);
foreach (DbSortClause clause in expression.SortOrder)
{
VisitExpression(clause.Expression);
}
VisitExpressionBindingPost(expression.Input);
VisitExpression(expression.Count);
}
public override DbExpression Visit(DbSkipExpression expression)
{
Check.NotNull(expression, "expression");
var found = Find(expression.Input.Expression);
if (!ReferenceEquals(found, expression.Input.Expression))
{
return(found.BindAs(expression.Input.VariableName).Skip(expression.SortOrder, expression.Count));
}
else
{
return(expression);
}
}
public override SqlFragment Visit(DbSkipExpression expression)
{
SelectStatement select = VisitInputExpressionEnsureSelect(expression.Input.Expression, expression.Input.VariableName,
expression.Input.VariableType);
foreach (DbSortClause sortClause in expression.SortOrder)
{
select.AddOrderBy(
new SortFragment(sortClause.Expression.Accept(this), sortClause.Ascending));
}
select = WrapIfNotCompatible(select, expression.ExpressionKind);
select.Skip = expression.Count.Accept(this);
return(select);
}
/// <summary>
/// Resturns true
/// </summary>
/// <param name="expression"> </param>
/// <returns> </returns>
/// <exception cref="NotSupportedException">expression.Count is DbParameterReferenceExpression</exception>
public override bool Visit(DbSkipExpression expression)
{
Check.NotNull(expression, "expression");
if (expression.Count is DbParameterReferenceExpression)
{
throw new NotSupportedException(Strings.SqlGen_ParameterForSkipNotSupportedOnSql8);
}
//Walk the structure in case a non-supported construct is encountered
VisitExpressionBinding(expression.Input);
VisitSortClauseList(expression.SortOrder);
VisitExpression(expression.Count);
return(true);
}
/// <summary>
/// Visitor pattern method for <see cref="DbSkipExpression"/>.
/// </summary>
/// <param name="expression">The DbSkipExpression that is being visited.</param>
/// <exception cref="ArgumentNullException"><paramref name="expression"/> is null</exception>
public override void Visit(DbSkipExpression expression)
{
// #433613: PreSharp warning 56506: Parameter 'expression' to this public method must be validated: A null-dereference can occur here.
EntityUtil.CheckArgumentNull(expression, "expression");
VisitExpressionBindingPre(expression.Input);
foreach (DbSortClause sortKey in expression.SortOrder)
{
VisitExpression(sortKey.Expression);
}
VisitExpressionBindingPost(expression.Input);
VisitExpression(expression.Count);
}
public override void Visit(DbSkipExpression e)
{
Check.NotNull(e, "e");
Begin(e);
Dump(e.Input, "Input");
Dump(e.SortOrder);
Dump(e.Count, "Count");
End(e);
}
public override void Visit(DbSkipExpression e)
{
VisitExprKind(e.ExpressionKind);
_key.Append('(');
VisitBinding(e.Input);
VisitSortOrder(e.SortOrder);
_key.Append('(');
e.Count.Accept(this);
_key.Append("))");
}
/// <summary>
/// Logicaly, <see cref="DbSkipExpression"/> translates to:
/// SELECT Y.x1, Y.x2, ..., Y.xn
/// FROM (
/// SELECT X.x1, X.x2, ..., X.xn,
/// FROM input AS X
/// EXCEPT
/// SELECT TOP(count) Z.x1, Z.x2, ..., Z.xn
/// FROM input AS Z
/// ORDER BY sk1, sk2, ...
/// ) AS Y
/// ORDER BY sk1, sk2, ...
///
/// Here, input refers to the input of the <see cref="DbSkipExpression"/>, and count to the count property of the <see cref="DbSkipExpression"/>.
/// The implementation of EXCEPT is non-duplicate eliminating, and does equality comparison only over the
/// equality comparable columns of the input.
///
/// This corresponds to the following expression tree:
///
/// SORT
/// |
/// NON-DISTINCT EXCEPT (specially translated, <see cref="TransformIntersectOrExcept(DbExpression left, DbExpression right, DbExpressionKind expressionKind, IList<DbPropertyExpression> sortExpressionsOverLeft, string sortExpressionsBindingVariableName)"/>
/// |
/// | - Left: clone of input
/// | - Right:
/// |
/// Limit
/// |
/// | - Limit: Count
/// | - Input
/// |
/// Sort
/// |
/// input
///
/// </summary>
/// <param name="e"></param>
/// <returns></returns>
public override DbExpression Visit(DbSkipExpression e)
{
//Build the right input of the except
DbExpression rightInput = VisitExpressionBinding(e.Input).Sort(VisitSortOrder(e.SortOrder)).Limit(VisitExpression(e.Count));
//Build the left input for the except
var leftInput = VisitExpression(e.Input.Expression); //Another copy of the input
var sortOrder = VisitSortOrder(e.SortOrder); //Another copy of the sort order
// Create a list of the sort expressions to be used for translating except
IList<DbPropertyExpression> sortExpressions = new List<DbPropertyExpression>(e.SortOrder.Count);
foreach (var sortClause in sortOrder)
{
//We only care about property expressions, not about constants
if (sortClause.Expression.ExpressionKind
== DbExpressionKind.Property)
{
sortExpressions.Add((DbPropertyExpression)sortClause.Expression);
}
}
var exceptExpression = TransformIntersectOrExcept(
leftInput, rightInput, DbExpressionKind.Skip, sortExpressions, e.Input.VariableName);
DbExpression result = exceptExpression.BindAs(e.Input.VariableName).Sort(sortOrder);
return result;
}
/// <summary> /// Visitor pattern method for DbSkipExpression. /// </summary> /// <param name="expression"> The DbSkipExpression that is being visited. </param> public abstract void Visit(DbSkipExpression expression);
internal LimitSkipLifter(DbLimitExpression limit, DbSkipExpression skip, AliasGenerator aliasGenerator)
: base(limit, aliasGenerator)
{
_limit = limit;
_skip = skip;
_source = skip.Input.Expression;
}
public override void Visit(DbSkipExpression expression) { }
public override void Visit(DbSkipExpression expression)
{
throw new NotSupportedException("Visit(\"SkipExpression\") is not supported.");
}
/// <summary>
/// Visitor pattern method for <see cref="DbSkipExpression" />.
/// </summary>
/// <param name="expression"> The DbLimitExpression that is being visited. </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="expression" />
/// is null
/// </exception>
public override void Visit(DbSkipExpression expression)
{
Check.NotNull(expression, "expression");
VisitExpressionBindingPre(expression.Input);
foreach (var s in expression.SortOrder)
{
VisitExpression(s.Expression);
}
VisitExpressionBindingPost(expression.Input);
VisitExpression(expression.Count);
}
public override DbExpression Visit(DbSkipExpression expression)
{
DbExpression found = Find(expression.Input.Expression);
if (!object.ReferenceEquals(found, expression.Input.Expression))
{
return found.BindAs(expression.Input.VariableName).Skip(expression.SortOrder, expression.Count);
}
else
{
return expression;
}
}
public override SqlFragment Visit(DbSkipExpression expression)
{
SelectStatement select = VisitInputExpressionEnsureSelect(expression.Input.Expression, expression.Input.VariableName,
expression.Input.VariableType);
foreach (DbSortClause sortClause in expression.SortOrder)
{
select.AddOrderBy(
new SortFragment(sortClause.Expression.Accept(this), sortClause.Ascending));
}
select = WrapIfNotCompatible(select, expression.ExpressionKind);
select.Skip = expression.Count.Accept(this);
return select;
}
internal SkipLifter(DbSkipExpression skip, AliasGenerator aliasGenerator)
: base(skip, aliasGenerator)
{
_skip = skip;
_source = skip.Input.Expression;
}
internal ProjectSkipLifter(DbProjectExpression project, DbSkipExpression skip, AliasGenerator aliasGenerator)
: base(project, aliasGenerator)
{
_project = project;
_skip = skip;
_source = _skip.Input.Expression;
}
public override void Visit(DbSkipExpression e)
{
Begin(e);
Dump(e.Input, "Input");
Dump(e.SortOrder);
Dump(e.Count, "Count");
End(e);
}
public override void Visit(DbSkipExpression expression)
{
Contract.Requires(expression != null);
}
public override SqlFragment Visit(DbSkipExpression expression)
{
SelectStatement select = VisitInputExpressionEnsureSelect(expression.Input.Expression, expression.Input.VariableName,
expression.Input.VariableType);
select = WrapIfNotCompatible(select, DbExpressionKind.Sort);
foreach (DbSortClause sortClause in expression.SortOrder)
{
select.AddOrderBy(
new SortFragment(sortClause.Expression.Accept(this), sortClause.Ascending));
}
// if we wrapped above, then this wrap will not create a new one so there
// is no harm in calling it
select = WrapIfNotCompatible(select, expression.ExpressionKind);
select.Skip = expression.Count.Accept(this);
return select;
}
protected DbSkipExpression RebindSkip(DbExpression input, DbSkipExpression skip, DbExpression k)
{
DbExpressionBinding inputBinding = input.BindAs(skip.Input.VariableName);
return inputBinding.Skip(skip.SortOrder, k);
}
protected DbSortExpression ApplySkipOrderToSort(DbExpression input, DbSkipExpression sortSpec)
{
DbExpressionBinding inputBinding = input.BindAs(sortSpec.Input.VariableName);
return inputBinding.Sort(sortSpec.SortOrder);
}
public override void Visit(DbSkipExpression expression)
{
if (expression == null) throw new ArgumentException("expression");
VisitExpressionBindingPre(expression.Input);
foreach (DbSortClause clause in expression.SortOrder)
{
VisitExpression(clause.Expression);
}
VisitExpressionBindingPost(expression.Input);
VisitExpression(expression.Count);
}
/// <summary>
/// Visitor pattern method for <see cref="DbSkipExpression"/>.
/// </summary>
/// <param name="expression">The DbSkipExpression that is being visited.</param>
/// <exception cref="ArgumentNullException"><paramref name="expression"/> is null</exception>
public override void Visit(DbSkipExpression expression)
{
VisitExpressionBindingPre(expression.Input);
foreach (var sortKey in expression.SortOrder)
{
VisitExpression(sortKey.Expression);
}
VisitExpressionBindingPost(expression.Input);
VisitExpression(expression.Count);
}
protected DbSkipExpression AddToSkip(DbExpression input, DbSkipExpression skip, DbExpression plusK)
{
// source.Skip(k, o).Skip(k2) -> source.Skip(k + k2, o)
DbExpression newCount = CombineIntegers(skip.Count, plusK,
(l, r) => l + r);
return RebindSkip(input, skip, newCount);
}
public override DbExpression Visit(DbSkipExpression expression)
{
Check.NotNull(expression, "expression");
var found = Find(expression.Input.Expression);
if (!ReferenceEquals(found, expression.Input.Expression))
{
return found.BindAs(expression.Input.VariableName).Skip(expression.SortOrder, expression.Count);
}
else
{
return expression;
}
}
