public BrowseVariant(PlanNode node, int originIndex, bool forward, bool inclusive) : base()
{
_node = node;
_originIndex = originIndex;
_forward = forward;
_inclusive = inclusive;
}
public override void DetermineDataType(Plan plan)
{
base.DetermineDataType(plan);
if (Nodes[0].DataType is Schema.ScalarType)
{
Schema.TableType tableType = (Schema.TableType)Nodes[1].DataType;
if (tableType.Columns.Count != 1)
{
throw new CompilerException(CompilerException.Codes.InvalidMembershipOperand, plan.CurrentStatement(), Nodes[0].DataType.Name, Nodes[1].DataType.Name);
}
#if USECOLUMNLOCATIONBINDING
FEqualNode =
Compiler.EmitBinaryNode
(
APlan,
new StackReferenceNode(Nodes[0].DataType, 1, true),
Instructions.Equal,
new StackColumnReferenceNode(tableType.Columns[0].DataType, 0, 0)
);
#else
_equalNode =
Compiler.EmitBinaryNode
(
plan,
new StackReferenceNode(Nodes[0].DataType, 1, true),
Instructions.Equal,
new StackColumnReferenceNode(tableType.Columns[0].Name, tableType.Columns[0].DataType, 0)
);
#endif
}
else
{
_equalNode = Compiler.EmitBinaryNode(plan, new StackReferenceNode(Nodes[0].DataType, 1, true), Instructions.Equal, new StackReferenceNode(((Schema.TableType)Nodes[1].DataType).RowType, 0, true));
}
}
private PlanNode GetSourceNode(Plan plan)
{
if (_sourceNode == null)
{
_sourceNode = Compiler.CompileExpression(plan, _sourceExpression);
}
return(_sourceNode);
}
protected override void InternalClone(PlanNode newNode)
{
base.InternalClone(newNode);
var newExtractRowNode = (ExtractRowNode)newNode;
newExtractRowNode.IndexerExpression = _indexerExpression;
}
protected override void InternalClone(PlanNode newNode)
{
base.InternalClone(newNode);
var newInstructionNode = (InstructionNode)newNode;
newInstructionNode.Operator = _operator;
}
protected override void InternalClone(PlanNode newNode)
{
base.InternalClone(newNode);
var newCursorNode = (CursorNode)newNode;
newCursorNode.CursorContext = _cursorContext;
}
protected override void InternalClone(PlanNode newNode)
{
base.InternalClone(newNode);
var newRowProjectNodeBase = (RowProjectNodeBase)newNode;
newRowProjectNodeBase._columnNames = _columnNames;
}
protected override void InternalClone(PlanNode newNode)
{
base.InternalClone(newNode);
var newRowNode = (RowNode)newNode;
newRowNode.SpecifiedRowType = _specifiedRowType;
}
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 InternalClone(PlanNode newNode)
{
base.InternalClone(newNode);
var newExtractColumnNode = (ExtractColumnNode)newNode;
newExtractColumnNode.Identifier = Identifier;
newExtractColumnNode._shouldDisposeSource = _shouldDisposeSource;
}
protected override void InternalClone(PlanNode newNode)
{
base.InternalClone(newNode);
var newRowRedefineNode = (RowRedefineNode)newNode;
newRowRedefineNode._redefineColumnOffsets = (int[])_redefineColumnOffsets.Clone();
newRowRedefineNode._expressions = _expressions;
}
protected override void InternalClone(PlanNode newNode)
{
base.InternalClone(newNode);
var newRowExtendNode = (RowExtendNode)newNode;
newRowExtendNode._extendColumnOffset = _extendColumnOffset;
newRowExtendNode._expressions = _expressions;
}
protected override void InternalClone(PlanNode newNode)
{
base.InternalClone(newNode);
if (_equalNode != null)
{
var newRowJoinNode = (RowJoinNode)newNode;
newRowJoinNode._equalNode = _equalNode.Clone();
}
}
protected override void InternalClone(PlanNode newNode)
{
base.InternalClone(newNode);
var newAggregateNode = (AggregateCallNode)newNode;
newAggregateNode.Operator = _operator;
newAggregateNode.AggregateColumnIndexes = _aggregateColumnIndexes;
newAggregateNode.ValueNames = _valueNames;
}
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 override void InternalClone(PlanNode newNode)
{
base.InternalClone(newNode);
var newRowRenameNode = (RowRenameNode)newNode;
newRowRenameNode._rowAlias = _rowAlias;
newRowRenameNode._metaData = _metaData;
newRowRenameNode._expressions = _expressions;
newRowRenameNode._shouldEmit = _shouldEmit;
}
public static string CharacteristicsToString(PlanNode node)
{
StringBuilder stringValue = new StringBuilder();
stringValue.Append(node.IsLiteral ? Strings.Get("Characteristics.Literal") : Strings.Get("Characteristics.NonLiteral"));
stringValue.AppendFormat(", {0}", node.IsFunctional ? Strings.Get("Characteristics.Functional") : Strings.Get("Characteristics.NonFunctional"));
stringValue.AppendFormat(", {0}", node.IsDeterministic ? Strings.Get("Characteristics.Deterministic") : Strings.Get("Characteristics.NonDeterministic"));
stringValue.AppendFormat(", {0}", node.IsRepeatable ? Strings.Get("Characteristics.Repeatable") : Strings.Get("Characteristics.NonRepeatable"));
stringValue.AppendFormat(", {0}", node.IsNilable ? Strings.Get("Characteristics.Nilable") : Strings.Get("Characteristics.NonNilable"));
return(stringValue.ToString());
}
protected PlanNode EmitBrowseConditionNode
(
Plan plan,
Schema.Order order,
Schema.IRowType origin,
bool forward,
bool inclusive
)
{
PlanNode node = null;
for (int orderIndex = order.Columns.Count - 1; orderIndex >= 0; orderIndex--)
{
if ((origin != null) && (orderIndex < origin.Columns.Count))
{
node =
Compiler.AppendNode
(
plan,
node,
Instructions.Or,
EmitBrowseOriginNode(plan, order, forward, inclusive, orderIndex)
);
}
else
#if USEINCLUDENILSWITHBROWSE
if (order.Columns[orderIndex].Column.IsNilable && !order.Columns[orderIndex].IncludeNils)
#endif
{
node =
Compiler.AppendNode
(
plan,
node,
Instructions.And,
EmitBrowseNilNode(plan, order.Columns[orderIndex].Column, false)
);
}
}
if (node == null)
{
node = new ValueNode(plan.DataTypes.SystemBoolean, inclusive);
}
return(node);
}
protected bool ReferencesUpdatedColumn(PlanNode node, BitArray valueFlags)
{
IList <string> columnReferences = new List <string>();
if (!node.IsContextLiteral(0, columnReferences))
{
// If we cannot tell which column was referenced (variable level reference)
// Or we cannot tell what columns were updated (no value flags)
// Or any column references were to columns that were updated
if (columnReferences.Count == 0 || valueFlags == null || (columnReferences.Select(c => DataType.Columns.IndexOfName(c)).Any(i => i >= 0 && i < _extendColumnOffset && valueFlags[i])))
{
return(true);
}
}
return(false);
}
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();
}
}
}
// The logic here uses unique preserving to support key inference, not the strictly stronger order preserving used for sargability
protected bool IsColumnReferencing(PlanNode node, ref string columnName)
{
StackColumnReferenceNode localNode = node as StackColumnReferenceNode;
if ((localNode != null) && (localNode.Location == 0))
{
columnName = localNode.Identifier;
return(true);
}
else if (node.IsUniquePreserving && (node.NodeCount == 1))
{
return(IsColumnReferencing(node.Nodes[0], ref columnName));
}
else
{
return(false);
}
}
public override void DetermineDataType(Plan APlan)
{
APlan.PushCursorContext(new CursorContext(CursorType.Static, CursorCapability.Navigable | CursorCapability.Updateable, CursorIsolation.None));
try
{
if (APlan.Catalog.Generators == null)
{
throw new Schema.SchemaException(Schema.SchemaException.Codes.NoGeneratorTable);
}
FNode = Compiler.EmitBaseTableVarNode(APlan, APlan.Catalog.Generators);
APlan.Symbols.PushWindow(0);
try
{
// push a string or IString depending on what the id column is
if (((Schema.Column)APlan.Catalog.Generators.DataType.Columns["ID"]).DataType == APlan.Catalog.DataTypes.SystemString)
{
APlan.Symbols.Push(new DataVar("AID", APlan.Catalog.DataTypes.SystemString));
}
else
{
APlan.Symbols.Push(new DataVar("AID", APlan.Catalog.DataTypes.SystemIString));
}
try
{
FNode = Compiler.EmitRestrictNode(APlan, FNode, new BinaryExpression(new IdentifierExpression("ID"), Language.D4.Instructions.Equal, new IdentifierExpression("AID")));
FNode = Compiler.Bind(APlan, FNode);
}
finally
{
APlan.Symbols.Pop();
}
}
finally
{
APlan.Symbols.PopWindow();
}
}
finally
{
APlan.PopCursorContext();
}
}
public override Statement EmitStatement(EmitMode mode)
{
ExplodeExpression expression = new ExplodeExpression();
expression.Expression = (Expression)Nodes[0].EmitStatement(mode);
PlanNode rootNode = Nodes[1];
OrderNode orderNode = rootNode as OrderNode;
if (orderNode != null)
{
expression.HasOrderByClause = true;
for (int index = 0; index < orderNode.RequestedOrder.Columns.Count; index++)
{
expression.OrderColumns.Add(orderNode.RequestedOrder.Columns[index].EmitStatement(mode));
}
rootNode = rootNode.Nodes[0];
}
expression.RootExpression = ((RestrictExpression)rootNode.EmitStatement(mode)).Condition;
PlanNode byNode = Nodes[2];
if (byNode is OrderNode)
{
byNode = byNode.Nodes[0];
}
expression.ByExpression = ((RestrictExpression)byNode.EmitStatement(mode)).Condition;
if (_levelColumnIndex >= 0)
{
Schema.TableVarColumn levelColumn = TableVar.Columns[_levelColumnIndex];
expression.LevelColumn = new IncludeColumnExpression(levelColumn.Name, levelColumn.MetaData == null ? null : levelColumn.MetaData.Copy());
}
if (_sequenceColumnIndex >= 0)
{
Schema.TableVarColumn sequenceColumn = TableVar.Columns[_sequenceColumnIndex];
expression.SequenceColumn = new IncludeColumnExpression(sequenceColumn.Name, sequenceColumn.MetaData == null ? null : sequenceColumn.MetaData.Copy());
}
expression.Modifiers = Modifiers;
return(expression);
}
protected PlanNode EmitBrowseOriginNode
(
Plan plan,
Schema.Order order,
bool forward,
bool inclusive,
int originIndex
)
{
PlanNode node = null;
for (int index = 0; index < originIndex; index++)
{
PlanNode equalNode = EmitBrowseColumnNode(plan, order.Columns[index], Instructions.Equal);
node = Compiler.AppendNode(plan, node, Instructions.And, equalNode);
}
node =
Compiler.AppendNode
(
plan,
node,
Instructions.And,
EmitBrowseComparisonNode(plan, order, forward, inclusive, originIndex)
);
for (int index = originIndex + 1; index < order.Columns.Count; index++)
{
if (order.Columns[index].Column.IsNilable && !order.Columns[index].IncludeNils)
{
node =
Compiler.AppendNode
(
plan,
node,
Instructions.And,
EmitBrowseNilNode(plan, order.Columns[index].Column, false)
);
}
}
return(node);
}
private void EnsureValidateNode(Plan plan)
{
if (_validateNode == null)
{
plan.Symbols.Push(new Symbol("ARow", TableVar.DataType.RowType));
try
{
// ARow in (((table { ARow }) union <source expression>) <quota clause>)
QuotaExpression quotaExpression = (QuotaExpression)EmitStatement(EmitMode.ForCopy);
quotaExpression.Expression = new UnionExpression(new TableSelectorExpression(new Expression[] { new IdentifierExpression("ARow") }), quotaExpression.Expression);
Expression validateExpression = new BinaryExpression(new IdentifierExpression("ARow"), Instructions.In, quotaExpression);
_validateNode = Compiler.Compile(plan, validateExpression).ExtractNode <ExpressionStatementNode>().Nodes[0];
}
finally
{
plan.Symbols.Pop();
}
}
}
private PlanNode ReplaceColumnReferences(Plan plan, PlanNode node, string identifier, int columnIndex)
{
if (node is StackReferenceNode)
{
#if USECOLUMNLOCATIONBINDING
return(new StackColumnReferenceNode(AIdentifier, ANode.DataType, ((StackReferenceNode)ANode).Location, AColumnIndex));
#else
return(new StackColumnReferenceNode(identifier, node.DataType, ((StackReferenceNode)node).Location));
#endif
}
else
{
for (int index = 0; index < node.NodeCount; index++)
{
node.Nodes[index] = ReplaceColumnReferences(plan, node.Nodes[index], identifier, columnIndex);
}
return(node);
}
}
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 virtual void InternalClone(PlanNode newNode)
{
newNode.IsLiteral = IsLiteral;
newNode.IsFunctional = IsFunctional;
newNode.IsDeterministic = IsDeterministic;
newNode.IsRepeatable = IsRepeatable;
newNode.IsNilable = IsNilable;
newNode.IsUniquePreserving = IsUniquePreserving;
newNode.IsOrderPreserving = IsOrderPreserving;
newNode.Modifiers = _modifiers;
newNode.IgnoreUnsupported = IgnoreUnsupported;
newNode.ShouldSupport = ShouldSupport;
newNode.LineInfo = LineInfo;
newNode.DataType = _dataType;
newNode.IsBreakable = IsBreakable;
if (_nodes != null)
{
for (int i = 0; i < _nodes.Count; i++)
{
newNode.Nodes.Add(_nodes[i].Clone());
}
}
}
protected PlanNode EmitBrowseComparisonNode
(
Plan plan,
Schema.Order order,
bool forward,
bool inclusive,
int originIndex
)
{
PlanNode node = null;
Schema.OrderColumn originColumn = order.Columns[originIndex];
if (originColumn.Ascending != forward)
{
if (inclusive && (originIndex == order.Columns.Count - 1))
{
node = EmitBrowseColumnNode(plan, originColumn, Instructions.InclusiveLess);
}
else
{
node = EmitBrowseColumnNode(plan, originColumn, Instructions.Less);
}
}
else
{
if (inclusive && (originIndex == order.Columns.Count - 1))
{
node = EmitBrowseColumnNode(plan, originColumn, Instructions.InclusiveGreater);
}
else
{
node = EmitBrowseColumnNode(plan, originColumn, Instructions.Greater);
}
}
return(node);
}
public DevicePlanNode(PlanNode node) : base()
{
_node = node;
}
