protected override void InternalBindingTraversal(Plan plan, PlanNodeVisitor visitor)
{
base.InternalBindingTraversal(plan, visitor);
#if UseScannedDifference
Schema.IRowType leftRowType = DataType.CreateRowType(Keywords.Left);
APlan.Symbols.Push(new Symbol(leftRowType));
try
{
Schema.IRowType rightRowType = DataType.CreateRowType(Keywords.Right);
APlan.Symbols.Push(new Symbol(rightRowType));
try
{
FEqualNode.BindingTraversal(APlan, visitor);
}
finally
{
APlan.Symbols.Pop();
}
}
finally
{
APlan.Symbols.Pop();
}
#endif
}
// BindingTraversal
public virtual void BindingTraversal(Plan plan, PlanNodeVisitor visitor)
{
if (visitor != null)
{
visitor.PreOrderVisit(plan, this);
}
if (_dataType != null)
{
plan.PushTypeContext(_dataType);
}
try
{
InternalBindingTraversal(plan, visitor);
}
finally
{
if (_dataType != null)
{
plan.PopTypeContext(_dataType);
}
}
if (visitor != null)
{
visitor.PostOrderVisit(plan, this);
}
}
protected override void InternalBindingTraversal(Plan plan, PlanNodeVisitor visitor)
{
#if USEVISIT
Nodes[0] = visitor.Visit(plan, Nodes[0]);
#else
Nodes[0].BindingTraversal(plan, visitor);
#endif
plan.EnterRowContext();
try
{
plan.Symbols.Push(new Symbol(String.Empty, DataType.RowType));
try
{
#if USEVISIT
Nodes[1] = visitor.Visit(plan, Nodes[1]);
#else
Nodes[1].BindingTraversal(plan, visitor);
#endif
}
finally
{
plan.Symbols.Pop();
}
}
finally
{
plan.ExitRowContext();
}
}
protected override void InternalBindingTraversal(Plan plan, PlanNodeVisitor visitor)
{
#if USEVISIT
Nodes[0] = visitor.Visit(plan, Nodes[0]);
#else
Nodes[0].BindingTraversal(plan, visitor);
#endif
plan.EnterRowContext();
try
{
plan.Symbols.Push(new Symbol(String.Empty, SourceTableType.RowType));
try
{
for (int index = 1; index < Nodes.Count; index++)
#if USEVISIT
{ Nodes[index] = visitor.Visit(plan, Nodes[index]); }
#else
{ Nodes[index].BindingTraversal(plan, visitor); }
#endif
}
finally
{
plan.Symbols.Pop();
}
}
finally
{
plan.ExitRowContext();
}
}
protected override void InternalBindingTraversal(Plan plan, PlanNodeVisitor visitor)
{
#if USEVISIT
Nodes[0] = visitor.Visit(plan, Nodes[0]);
Nodes[1] = visitor.Visit(plan, Nodes[1]);
#else
Nodes[0].BindingTraversal(plan, visitor);
Nodes[1].BindingTraversal(plan, visitor);
#endif
if (_comparisonNode != null)
{
plan.Symbols.PushWindow(0);
try
{
plan.EnterRowContext();
try
{
#if USENAMEDROWVARIABLES
plan.Symbols.Push(new Symbol(Keywords.Left, (Schema.RowType)Nodes[0].DataType));
#else
APlan.Symbols.Push(new Symbol(String.Empty, new Schema.RowType(((Schema.RowType)Nodes[0].DataType).Columns, Keywords.Left)));
#endif
try
{
#if USENAMEDROWVARIABLES
plan.Symbols.Push(new Symbol(Keywords.Right, (Schema.RowType)Nodes[1].DataType));
#else
APlan.Symbols.Push(new Symbol(String.Empty, new Schema.RowType(((Schema.RowType)Nodes[1].DataType).Columns, Keywords.Right)));
#endif
try
{
#if USEVISIT
_comparisonNode = visitor.Visit(plan, _comparisonNode);
#else
_comparisonNode.BindingTraversal(plan, visitor);
#endif
}
finally
{
plan.Symbols.Pop();
}
}
finally
{
plan.Symbols.Pop();
}
}
finally
{
plan.ExitRowContext();
}
}
finally
{
plan.Symbols.PopWindow();
}
}
}
protected override void InternalBindingTraversal(Plan plan, PlanNodeVisitor visitor)
{
#if USEVISIT
Nodes[0] = visitor.Visit(plan, Nodes[0]);
Nodes[1] = visitor.Visit(plan, Nodes[1]);
#else
LeftTableNode.BindingTraversal(plan, visitor);
RightTableNode.BindingTraversal(plan, visitor);
#endif
plan.Symbols.PushWindow(0);
try
{
plan.EnterRowContext();
try
{
#if USENAMEDROWVARIABLES
plan.Symbols.Push(new Symbol(Keywords.Left, LeftTableNode.DataType.RowType));
#else
APlan.Symbols.Push(new Symbol(String.Empty, LeftTableNode.DataType.CreateRowType(Keywords.Left)));
#endif
try
{
#if USENAMEDROWVARIABLES
plan.Symbols.Push(new Symbol(Keywords.Right, RightTableNode.DataType.RowType));
#else
APlan.Symbols.Push(new Symbol(String.Empty, RightTableNode.DataType.CreateRowType(Keywords.Right)));
#endif
try
{
#if USEVISIT
_rowEqualNode = visitor.Visit(plan, _rowEqualNode);
#else
RowEqualNode.BindingTraversal(plan, visitor);
#endif
}
finally
{
plan.Symbols.Pop();
}
}
finally
{
plan.Symbols.Pop();
}
}
finally
{
plan.ExitRowContext();
}
}
finally
{
plan.Symbols.PopWindow();
}
}
protected virtual void InternalBindingTraversal(Plan plan, PlanNodeVisitor visitor)
{
if (_nodes != null)
{
for (int index = 0; index < _nodes.Count; index++)
#if USEVISIT
{ _nodes[index] = visitor.Visit(plan, Nodes[index]); }
}
#else
{ _nodes[index].BindingTraversal(plan, visitor); }
#endif
}
protected override void InternalBindingTraversal(Plan plan, PlanNodeVisitor visitor)
{
base.InternalBindingTraversal(plan, visitor);
#if USECLEANUPNODES
if (CleanupNodes != null)
{
foreach (PlanNode node in CleanupNodes)
{
node.BindingTraversal(APlan, visitor);
}
}
#endif
}
protected override void InternalBindingTraversal(Plan plan, PlanNodeVisitor visitor)
{
plan.PushCursorContext(_cursorContext);
try
{
#if USEVISIT
Nodes[0] = visitor.Visit(plan, Nodes[0]);
#else
SourceNode.BindingTraversal(plan, visitor);
#endif
}
finally
{
plan.PopCursorContext();
}
}
protected override void InternalBindingTraversal(Plan plan, PlanNodeVisitor visitor)
{
base.InternalBindingTraversal(plan, visitor);
// If _distinctRequired is true, _equalNode will only be null if the key is not comparable (i.e. a hashtable is being used to support the distinct)
if (_distinctRequired && _equalNode != null)
{
plan.EnterRowContext();
try
{
#if USENAMEDROWVARIABLES
plan.Symbols.Push(new Symbol(Keywords.Left, DataType.RowType));
#else
APlan.Symbols.Push(new Symbol(String.Empty, DataType.CreateRowType(Keywords.Left)));
#endif
try
{
#if USENAMEDROWVARIABLES
plan.Symbols.Push(new Symbol(Keywords.Right, DataType.RowType));
#else
APlan.Symbols.Push(new Symbol(String.Empty, DataType.CreateRowType(Keywords.Right)));
#endif
try
{
#if USEVISIT
_equalNode = visitor.Visit(plan, _equalNode);
#else
_equalNode.BindingTraversal(plan, visitor);
#endif
}
finally
{
plan.Symbols.Pop();
}
}
finally
{
plan.Symbols.Pop();
}
}
finally
{
plan.ExitRowContext();
}
}
}
protected override void InternalBindingTraversal(Plan plan, PlanNodeVisitor visitor)
{
base.InternalBindingTraversal(plan, visitor);
plan.EnterRowContext();
try
{
#if USENAMEDROWVARIABLES
plan.Symbols.Push(new Symbol(Keywords.Left, _quotaRowType));
#else
APlan.Symbols.Push(new Symbol(String.Empty, new Schema.RowType(FQuotaOrder.Columns, Keywords.Left)));
#endif
try
{
#if USENAMEDROWVARIABLES
plan.Symbols.Push(new Symbol(Keywords.Right, _quotaRowType));
#else
APlan.Symbols.Push(new Symbol(String.Empty, new Schema.RowType(FQuotaOrder.Columns, Keywords.Right)));
#endif
try
{
#if USEVISIT
_equalNode = visitor.Visit(plan, _equalNode);
#else
_equalNode.BindingTraversal(plan, visitor);
#endif
}
finally
{
plan.Symbols.Pop();
}
}
finally
{
plan.Symbols.Pop();
}
}
finally
{
plan.ExitRowContext();
}
}
protected override void InternalBindingTraversal(Plan plan, PlanNodeVisitor visitor)
{
#if USEVISIT
Nodes[0] = visitor.Visit(plan, Nodes[0]);
Nodes[1] = visitor.Visit(plan, Nodes[1]);
#else
Nodes[0].BindingTraversal(plan, visitor);
Nodes[1].BindingTraversal(plan, visitor);
#endif
plan.EnterRowContext();
try
{
#if USENAMEDROWVARIABLES
plan.Symbols.Push(new Symbol(Keywords.Parent, SourceTableType.RowType));
#else
APlan.Symbols.Push(new Symbol(String.Empty, SourceTableType.CreateRowType(Keywords.Parent)));
#endif
try
{
#if USEVISIT
Nodes[2] = visitor.Visit(plan, Nodes[2]);
#else
Nodes[2].BindingTraversal(plan, visitor);
#endif
}
finally
{
plan.Symbols.Pop();
}
}
finally
{
plan.ExitRowContext();
}
}
protected override void InternalBindingTraversal(Plan plan, PlanNodeVisitor visitor)
{
plan.Symbols.Push(new Symbol("LCounter", plan.DataTypes.SystemInteger));
}
protected override void InternalBindingTraversal(Plan plan, PlanNodeVisitor visitor)
{
plan.Symbols.PushWindow(0);
try
{
plan.Symbols.Push(new Symbol(Keywords.Result, _dataType));
try
{
#if USEVISIT
Nodes[1] = visitor.Visit(plan, Nodes[1]);
#else
Nodes[1].BindingTraversal(plan, visitor);
#endif
for (int index = 0; index < _aggregateColumnIndexes.Length; index++)
{
plan.Symbols.Push(new Symbol(_valueNames[index], SourceNode.DataType.Columns[_aggregateColumnIndexes[index]].DataType));
}
try
{
// This AllowExtraWindowAccess call remains in the runtime because it allows the
// determine binding step to find the reference to the external source restriction values
plan.Symbols.AllowExtraWindowAccess = true;
try
{
#if USEVISIT
Nodes[0] = visitor.Visit(plan, Nodes[0]);
#else
Nodes[0].BindingTraversal(plan, visitor);
#endif
}
finally
{
plan.Symbols.AllowExtraWindowAccess = false;
}
plan.Symbols.PushFrame();
try
{
#if USEVISIT
Nodes[2] = visitor.Visit(plan, Nodes[2]);
#else
Nodes[2].BindingTraversal(plan, visitor);
#endif
}
finally
{
plan.Symbols.PopFrame();
}
}
finally
{
for (int index = 0; index < _aggregateColumnIndexes.Length; index++)
{
plan.Symbols.Pop();
}
}
#if USEVISIT
Nodes[3] = visitor.Visit(plan, Nodes[3]);
#else
Nodes[3].BindingTraversal(plan, visitor);
#endif
}
finally
{
plan.Symbols.Pop();
}
}
finally
{
plan.Symbols.PopWindow();
}
}
