public override AlgebraNode VisitTopAlgebraNode(TopAlgebraNode node)
{
ShowPlanElement inputElement = ConvertNode(node.Input);
PropertyListBuilder propertyListBuilder = new PropertyListBuilder();
AddRowBufferEntries(propertyListBuilder, Resources.ShowPlanGroupOutputList, node.OutputList);
AddStatistics(propertyListBuilder, node.StatisticsIterator);
propertyListBuilder.Write(Resources.ShowPlanKeyLimit, node.Limit.ToString(CultureInfo.InvariantCulture));
if (node.TieEntries == null)
{
propertyListBuilder.Write(Resources.ShowPlanKeyWithTies, Boolean.FalseString);
}
else
{
propertyListBuilder.Write(Resources.ShowPlanKeyWithTies, Boolean.TrueString);
AddRowBufferEntries(propertyListBuilder, Resources.ShowPlanGroupTieColumns, node.TieEntries);
}
IList <ShowPlanProperty> properties = propertyListBuilder.ToList();
ShowPlanElement element = new ShowPlanElement(ShowPlanOperator.Top, properties, inputElement);
_currentElement = element;
return(node);
}
public override AlgebraNode VisitTopAlgebraNode(TopAlgebraNode node)
{
if (node.Limit == 0)
{
_willProduceAtLeastOneRow = false;
return node;
}
return base.VisitTopAlgebraNode(node);
}
public override AlgebraNode VisitTopAlgebraNode(TopAlgebraNode node)
{
if (node.Limit == 0)
{
_willProduceAtLeastOneRow = false;
return(node);
}
return(base.VisitTopAlgebraNode(node));
}
public override AlgebraNode VisitTopAlgebraNode(TopAlgebraNode node)
{
if (node.Limit == 0)
{
return(CreateNullScan(node.OutputList));
}
node.Input = VisitAlgebraNode(node.Input);
return(NullScanIfInputIsNullScan(node));
}
public override AstElement Clone(Dictionary<AstElement, AstElement> alreadyClonedElements)
{
TopAlgebraNode result = new TopAlgebraNode();
result.StatisticsIterator = StatisticsIterator;
result.OutputList = ArrayHelpers.Clone(OutputList);
result.Input = (AlgebraNode)Input.Clone(alreadyClonedElements);
result.Limit = _limit;
result.TieEntries = ArrayHelpers.Clone(_tieEntries);
return result;
}
public override AstElement Clone(Dictionary <AstElement, AstElement> alreadyClonedElements)
{
TopAlgebraNode result = new TopAlgebraNode();
result.StatisticsIterator = StatisticsIterator;
result.OutputList = ArrayHelpers.Clone(OutputList);
result.Input = (AlgebraNode)Input.Clone(alreadyClonedElements);
result.Limit = _limit;
result.TieEntries = ArrayHelpers.Clone(_tieEntries);
return(result);
}
public override AlgebraNode VisitTopAlgebraNode(TopAlgebraNode node)
{
_xmlWriter.WriteStartElement("topAlgebraNode");
_xmlWriter.WriteAttributeString("limit", XmlConvert.ToString(node.Limit));
WriteAstNode("input", node.Input);
_xmlWriter.WriteEndElement();
return(node);
}
public override AlgebraNode VisitTopAlgebraNode(TopAlgebraNode node)
{
base.VisitTopAlgebraNode(node);
if (node.TieEntries != null)
{
ReplaceRowBufferEntries(node.TieEntries);
}
return(node);
}
public override AlgebraNode VisitTopAlgebraNode(TopAlgebraNode node)
{
node.OutputList = RemovedUnneededRowBufferColumns(node.OutputList);
if (node.TieEntries != null)
{
foreach (RowBufferEntry tieColumn in node.TieEntries)
{
AddNeededRowBufferEntry(tieColumn);
}
}
return(base.VisitTopAlgebraNode(node));
}
public override AlgebraNode VisitTopAlgebraNode(TopAlgebraNode node)
{
if (node.Limit == 0)
return CreateNullScan(node.OutputList);
node.Input = VisitAlgebraNode(node.Input);
return NullScanIfInputIsNullScan(node);
}
public override AlgebraNode VisitTopAlgebraNode(TopAlgebraNode node)
{
return(ReturnInputIfItProducesJustOneRow(node));
}
public override AlgebraNode VisitTopAlgebraNode(TopAlgebraNode node)
{
_willProduceAtMostOneRow = node.Limit <= 1;
return node;
}
public override QueryNode VisitSelectQuery(SelectQuery query)
{
// Calculate needed row buffers
RowBufferCalculator rowBufferCalculator = query.RowBufferCalculator;
// Emit FROM
if (query.TableReferences != null)
{
Visit(query.TableReferences);
}
else
{
ConstantScanAlgebraNode constantScanAlgebraNode = new ConstantScanAlgebraNode();
constantScanAlgebraNode.DefinedValues = new ComputedValueDefinition[0];
SetLastAlgebraNode(constantScanAlgebraNode);
}
// Emit WHERE
if (query.WhereClause != null)
{
FilterAlgebraNode filterAlgebraNode = new FilterAlgebraNode();
filterAlgebraNode.Input = GetLastAlgebraNode();
filterAlgebraNode.Predicate = query.WhereClause;
SetLastAlgebraNode(filterAlgebraNode);
}
// Emit GROUP BY
if (query.GroupByColumns != null || query.IsAggregated)
{
EmitComputeScalarIfNeeded(rowBufferCalculator.ComputedGroupColumns);
List <AggregatedValueDefinition> definedValues = new List <AggregatedValueDefinition>();
foreach (AggregateExpression aggregateDependency in query.AggregateDependencies)
{
definedValues.Add(aggregateDependency.ValueDefinition);
}
if (query.GroupByColumns != null)
{
SortAlgebraNode sortAlgebraNode = new SortAlgebraNode();
sortAlgebraNode.Input = GetLastAlgebraNode();
sortAlgebraNode.SortEntries = rowBufferCalculator.GroupColumns;
sortAlgebraNode.SortOrders = CreateAscendingSortOrders(sortAlgebraNode.SortEntries.Length);
SetLastAlgebraNode(sortAlgebraNode);
}
AggregateAlgebraNode algebraNode = new AggregateAlgebraNode();
algebraNode.Input = GetLastAlgebraNode();
algebraNode.DefinedValues = definedValues.ToArray();
algebraNode.Groups = rowBufferCalculator.GroupColumns;
SetLastAlgebraNode(algebraNode);
}
// Emit HAVING
if (query.HavingClause != null)
{
FilterAlgebraNode filterAlgebraNode = new FilterAlgebraNode();
filterAlgebraNode.Input = GetLastAlgebraNode();
filterAlgebraNode.Predicate = query.HavingClause;
SetLastAlgebraNode(filterAlgebraNode);
}
// Emit compute scalar to calculate expressions needed in SELECT and ORDER BY
EmitComputeScalarIfNeeded(rowBufferCalculator.ComputedSelectAndOrderColumns);
// Emit DISTINCT and ORDER BY
if (query.IsDistinct && query.OrderByColumns != null)
{
List <RowBufferEntry> sortEntries = new List <RowBufferEntry>();
List <SortOrder> sortOrderList = new List <SortOrder>();
for (int i = 0; i < query.OrderByColumns.Length; i++)
{
sortEntries.Add(rowBufferCalculator.OrderColumns[i]);
sortOrderList.Add(query.OrderByColumns[i].SortOrder);
}
foreach (RowBufferEntry selectColumn in rowBufferCalculator.SelectColumns)
{
bool selectColumnMustBeSorted = !sortEntries.Contains(selectColumn);
if (selectColumnMustBeSorted)
{
sortEntries.Add(selectColumn);
sortOrderList.Add(SortOrder.Ascending);
}
}
SortAlgebraNode sortAlgebraNode = new SortAlgebraNode();
sortAlgebraNode.Distinct = true;
sortAlgebraNode.Input = GetLastAlgebraNode();
sortAlgebraNode.SortEntries = sortEntries.ToArray();
sortAlgebraNode.SortOrders = sortOrderList.ToArray();
SetLastAlgebraNode(sortAlgebraNode);
}
else
{
if (query.IsDistinct)
{
SortAlgebraNode sortAlgebraNode = new SortAlgebraNode();
sortAlgebraNode.Distinct = true;
sortAlgebraNode.Input = GetLastAlgebraNode();
sortAlgebraNode.SortEntries = rowBufferCalculator.SelectColumns;
sortAlgebraNode.SortOrders = CreateAscendingSortOrders(sortAlgebraNode.SortEntries.Length);
SetLastAlgebraNode(sortAlgebraNode);
}
if (query.OrderByColumns != null)
{
List <SortOrder> sortOrderList = new List <SortOrder>();
foreach (OrderByColumn orderByColumn in query.OrderByColumns)
{
sortOrderList.Add(orderByColumn.SortOrder);
}
SortAlgebraNode sortAlgebraNode = new SortAlgebraNode();
sortAlgebraNode.Input = GetLastAlgebraNode();
sortAlgebraNode.SortEntries = rowBufferCalculator.OrderColumns;
sortAlgebraNode.SortOrders = sortOrderList.ToArray();
SetLastAlgebraNode(sortAlgebraNode);
}
}
// Emit TOP
if (query.TopClause != null)
{
TopAlgebraNode algebraNode = new TopAlgebraNode();
algebraNode.Input = GetLastAlgebraNode();
algebraNode.Limit = query.TopClause.Value;
if (query.TopClause.WithTies)
{
algebraNode.TieEntries = rowBufferCalculator.OrderColumns;
}
SetLastAlgebraNode(algebraNode);
}
// Emit select list
List <string> columnNames = new List <string>();
foreach (SelectColumn columnSource in query.SelectColumns)
{
if (columnSource.Alias != null)
{
columnNames.Add(columnSource.Alias.Text);
}
else
{
columnNames.Add(null);
}
}
ResultAlgebraNode resultAlgebraNode = new ResultAlgebraNode();
resultAlgebraNode.Input = GetLastAlgebraNode();
resultAlgebraNode.OutputList = rowBufferCalculator.SelectColumns;
resultAlgebraNode.ColumnNames = columnNames.ToArray();
SetLastAlgebraNode(resultAlgebraNode);
return(query);
}
public virtual AlgebraNode VisitTopAlgebraNode(TopAlgebraNode node)
{
node.Input = VisitAlgebraNode(node.Input);
return(node);
}
public virtual AlgebraNode VisitTopAlgebraNode(TopAlgebraNode node)
{
node.Input = VisitAlgebraNode(node.Input);
return node;
}
public override AlgebraNode VisitTopAlgebraNode(TopAlgebraNode node)
{
_xmlWriter.WriteStartElement("topAlgebraNode");
_xmlWriter.WriteAttributeString("limit", XmlConvert.ToString(node.Limit));
WriteAstNode("input", node.Input);
_xmlWriter.WriteEndElement();
return node;
}
public override AlgebraNode VisitTopAlgebraNode(TopAlgebraNode node)
{
TopIterator topIterator;
if (node.TieEntries == null)
{
topIterator = new TopIterator();
}
else
{
TopWithTiesIterator topWithTiesIterator = new TopWithTiesIterator();
topWithTiesIterator.TieEntries = GetIteratorInput(node.Input.OutputList, node.TieEntries);
topIterator = topWithTiesIterator;
}
topIterator.RowBuffer = new object[node.OutputList.Length];
topIterator.Limit = node.Limit;
topIterator.Input = ConvertAlgebraNode(node.Input);
topIterator.InputOutput = GetIteratorOutput(0, node.Input.OutputList, node.OutputList);
SetLastIterator(node, topIterator);
return node;
}
public override AlgebraNode VisitTopAlgebraNode(TopAlgebraNode node)
{
base.VisitTopAlgebraNode(node);
if (node.TieEntries != null)
ReplaceRowBufferEntries(node.TieEntries);
return node;
}
public override QueryNode VisitSelectQuery(SelectQuery query)
{
// Calculate needed row buffers
RowBufferCalculator rowBufferCalculator = query.RowBufferCalculator;
// Emit FROM
if (query.TableReferences != null)
{
Visit(query.TableReferences);
}
else
{
ConstantScanAlgebraNode constantScanAlgebraNode = new ConstantScanAlgebraNode();
constantScanAlgebraNode.DefinedValues = new ComputedValueDefinition[0];
SetLastAlgebraNode(constantScanAlgebraNode);
}
// Emit WHERE
if (query.WhereClause != null)
{
FilterAlgebraNode filterAlgebraNode = new FilterAlgebraNode();
filterAlgebraNode.Input = GetLastAlgebraNode();
filterAlgebraNode.Predicate = query.WhereClause;
SetLastAlgebraNode(filterAlgebraNode);
}
// Emit GROUP BY
if (query.GroupByColumns != null || query.IsAggregated)
{
EmitComputeScalarIfNeeded(rowBufferCalculator.ComputedGroupColumns);
List<AggregatedValueDefinition> definedValues = new List<AggregatedValueDefinition>();
foreach (AggregateExpression aggregateDependency in query.AggregateDependencies)
definedValues.Add(aggregateDependency.ValueDefinition);
if (query.GroupByColumns != null)
{
SortAlgebraNode sortAlgebraNode = new SortAlgebraNode();
sortAlgebraNode.Input = GetLastAlgebraNode();
sortAlgebraNode.SortEntries = rowBufferCalculator.GroupColumns;
sortAlgebraNode.SortOrders = CreateAscendingSortOrders(sortAlgebraNode.SortEntries.Length);
SetLastAlgebraNode(sortAlgebraNode);
}
AggregateAlgebraNode algebraNode = new AggregateAlgebraNode();
algebraNode.Input = GetLastAlgebraNode();
algebraNode.DefinedValues = definedValues.ToArray();
algebraNode.Groups = rowBufferCalculator.GroupColumns;
SetLastAlgebraNode(algebraNode);
}
// Emit HAVING
if (query.HavingClause != null)
{
FilterAlgebraNode filterAlgebraNode = new FilterAlgebraNode();
filterAlgebraNode.Input = GetLastAlgebraNode();
filterAlgebraNode.Predicate = query.HavingClause;
SetLastAlgebraNode(filterAlgebraNode);
}
// Emit compute scalar to calculate expressions needed in SELECT and ORDER BY
EmitComputeScalarIfNeeded(rowBufferCalculator.ComputedSelectAndOrderColumns);
// Emit DISTINCT and ORDER BY
if (query.IsDistinct && query.OrderByColumns != null)
{
List<RowBufferEntry> sortEntries = new List<RowBufferEntry>();
List<SortOrder> sortOrderList = new List<SortOrder>();
for (int i = 0; i < query.OrderByColumns.Length; i++)
{
sortEntries.Add(rowBufferCalculator.OrderColumns[i]);
sortOrderList.Add(query.OrderByColumns[i].SortOrder);
}
foreach (RowBufferEntry selectColumn in rowBufferCalculator.SelectColumns)
{
bool selectColumnMustBeSorted = !sortEntries.Contains(selectColumn);
if (selectColumnMustBeSorted)
{
sortEntries.Add(selectColumn);
sortOrderList.Add(SortOrder.Ascending);
}
}
SortAlgebraNode sortAlgebraNode = new SortAlgebraNode();
sortAlgebraNode.Distinct = true;
sortAlgebraNode.Input = GetLastAlgebraNode();
sortAlgebraNode.SortEntries = sortEntries.ToArray();
sortAlgebraNode.SortOrders = sortOrderList.ToArray();
SetLastAlgebraNode(sortAlgebraNode);
}
else
{
if (query.IsDistinct)
{
SortAlgebraNode sortAlgebraNode = new SortAlgebraNode();
sortAlgebraNode.Distinct = true;
sortAlgebraNode.Input = GetLastAlgebraNode();
sortAlgebraNode.SortEntries = rowBufferCalculator.SelectColumns;
sortAlgebraNode.SortOrders = CreateAscendingSortOrders(sortAlgebraNode.SortEntries.Length);
SetLastAlgebraNode(sortAlgebraNode);
}
if (query.OrderByColumns != null)
{
List<SortOrder> sortOrderList = new List<SortOrder>();
foreach (OrderByColumn orderByColumn in query.OrderByColumns)
sortOrderList.Add(orderByColumn.SortOrder);
SortAlgebraNode sortAlgebraNode = new SortAlgebraNode();
sortAlgebraNode.Input = GetLastAlgebraNode();
sortAlgebraNode.SortEntries = rowBufferCalculator.OrderColumns;
sortAlgebraNode.SortOrders = sortOrderList.ToArray();
SetLastAlgebraNode(sortAlgebraNode);
}
}
// Emit TOP
if (query.TopClause != null)
{
TopAlgebraNode algebraNode = new TopAlgebraNode();
algebraNode.Input = GetLastAlgebraNode();
algebraNode.Limit = query.TopClause.Value;
if (query.TopClause.WithTies)
algebraNode.TieEntries = rowBufferCalculator.OrderColumns;
SetLastAlgebraNode(algebraNode);
}
// Emit select list
List<string> columnNames = new List<string>();
foreach (SelectColumn columnSource in query.SelectColumns)
{
if (columnSource.Alias != null)
columnNames.Add(columnSource.Alias.Text);
else
columnNames.Add(null);
}
ResultAlgebraNode resultAlgebraNode = new ResultAlgebraNode();
resultAlgebraNode.Input = GetLastAlgebraNode();
resultAlgebraNode.OutputList = rowBufferCalculator.SelectColumns;
resultAlgebraNode.ColumnNames = columnNames.ToArray();
SetLastAlgebraNode(resultAlgebraNode);
return query;
}
public override AlgebraNode VisitTopAlgebraNode(TopAlgebraNode node)
{
_willProduceAtMostOneRow = node.Limit <= 1;
return(node);
}
public override AlgebraNode VisitTopAlgebraNode(TopAlgebraNode node)
{
node.Input = VisitAlgebraNode(node.Input);
node.OutputList = node.Input.OutputList;
return node;
}
public override AlgebraNode VisitTopAlgebraNode(TopAlgebraNode node)
{
node.Input = VisitAlgebraNode(node.Input);
node.OutputList = node.Input.OutputList;
return(node);
}
public override AlgebraNode VisitTopAlgebraNode(TopAlgebraNode node)
{
return ReturnInputIfItProducesJustOneRow(node);
}
public override AlgebraNode VisitTopAlgebraNode(TopAlgebraNode node)
{
ShowPlanElement inputElement = ConvertNode(node.Input);
PropertyListBuilder propertyListBuilder = new PropertyListBuilder();
AddRowBufferEntries(propertyListBuilder, Resources.ShowPlanGroupOutputList, node.OutputList);
AddStatistics(propertyListBuilder, node.StatisticsIterator);
propertyListBuilder.Write(Resources.ShowPlanKeyLimit, node.Limit.ToString(CultureInfo.InvariantCulture));
if (node.TieEntries == null)
{
propertyListBuilder.Write(Resources.ShowPlanKeyWithTies, Boolean.FalseString);
}
else
{
propertyListBuilder.Write(Resources.ShowPlanKeyWithTies, Boolean.TrueString);
AddRowBufferEntries(propertyListBuilder, Resources.ShowPlanGroupTieColumns, node.TieEntries);
}
IList<ShowPlanProperty> properties = propertyListBuilder.ToList();
ShowPlanElement element = new ShowPlanElement(ShowPlanOperator.Top, properties, inputElement);
_currentElement = element;
return node;
}
