public override AlgebraNode VisitAggregateAlgebraNode(AggregateAlgebraNode node)
{
Visit(node.Input);
AddDefinedValues(node.DefinedValues);
return node;
}
public override AlgebraNode VisitAggregateAlgebraNode(AggregateAlgebraNode node)
{
node.OutputList = RemovedUnneededRowBufferColumns(node.OutputList);
if (node.Groups != null)
{
foreach (RowBufferEntry group in node.Groups)
{
AddNeededRowBufferEntry(group);
}
}
List <AggregatedValueDefinition> definedValues = new List <AggregatedValueDefinition>();
foreach (AggregatedValueDefinition definedValue in node.DefinedValues)
{
if (IsNeeded(definedValue.Target))
{
definedValues.Add(definedValue);
AddNeededRowBufferEntryReferences(definedValue.Argument);
}
}
node.DefinedValues = definedValues.ToArray();
return(base.VisitAggregateAlgebraNode(node));
}
public override AlgebraNode VisitAggregateAlgebraNode(AggregateAlgebraNode node)
{
Visit(node.Input);
AddDefinedValues(node.DefinedValues);
return(node);
}
public override AlgebraNode VisitAggregateAlgebraNode(AggregateAlgebraNode node)
{
base.VisitAggregateAlgebraNode(node);
if (node.Groups != null)
ReplaceRowBufferEntries(node.Groups);
return node;
}
public override AlgebraNode VisitAggregateAlgebraNode(AggregateAlgebraNode node)
{
base.VisitAggregateAlgebraNode(node);
foreach (AggregatedValueDefinition definedValue in node.DefinedValues)
NameEntry(definedValue.Target, EXPRESSION_NAME_FMT_STR);
return node;
}
public override AstElement Clone(Dictionary<AstElement, AstElement> alreadyClonedElements)
{
AggregateAlgebraNode result = new AggregateAlgebraNode();
result.StatisticsIterator = StatisticsIterator;
result.OutputList = ArrayHelpers.Clone(OutputList);
result.Input = (AlgebraNode)Input.Clone(alreadyClonedElements);
result.Groups = ArrayHelpers.Clone(_groups);
result.DefinedValues = ArrayHelpers.CreateDeepCopyOfAstElementArray(_definedValues, alreadyClonedElements);
return result;
}
public override AlgebraNode VisitAggregateAlgebraNode(AggregateAlgebraNode node)
{
base.VisitAggregateAlgebraNode(node);
foreach (AggregatedValueDefinition definedValue in node.DefinedValues)
{
NameEntry(definedValue.Target, EXPRESSION_NAME_FMT_STR);
}
return(node);
}
public override AlgebraNode VisitAggregateAlgebraNode(AggregateAlgebraNode node)
{
node.Input = VisitAlgebraNode(node.Input);
List<RowBufferEntry> outputList = new List<RowBufferEntry>();
outputList.AddRange(node.Input.OutputList);
outputList.AddRange(GetRowBufferEntries(node.DefinedValues));
node.OutputList = outputList.ToArray();
return node;
}
public override AstElement Clone(Dictionary <AstElement, AstElement> alreadyClonedElements)
{
AggregateAlgebraNode result = new AggregateAlgebraNode();
result.StatisticsIterator = StatisticsIterator;
result.OutputList = ArrayHelpers.Clone(OutputList);
result.Input = (AlgebraNode)Input.Clone(alreadyClonedElements);
result.Groups = ArrayHelpers.Clone(_groups);
result.DefinedValues = ArrayHelpers.CreateDeepCopyOfAstElementArray(_definedValues, alreadyClonedElements);
return(result);
}
public override AlgebraNode VisitAggregateAlgebraNode(AggregateAlgebraNode node)
{
base.VisitAggregateAlgebraNode(node);
if (node.Groups != null)
{
ReplaceRowBufferEntries(node.Groups);
}
return(node);
}
public override AlgebraNode VisitAggregateAlgebraNode(AggregateAlgebraNode node)
{
_xmlWriter.WriteStartElement("aggregateAlgebraNode");
WriteAstNode("input", node.Input);
WriteRowBufferEntries("groups", node.Groups);
//WriteAstNodes("aggregates", node.Aggregates);
_xmlWriter.WriteEndElement();
return(node);
}
public override AlgebraNode VisitAggregateAlgebraNode(AggregateAlgebraNode node)
{
node.Input = VisitAlgebraNode(node.Input);
List <RowBufferEntry> outputList = new List <RowBufferEntry>();
outputList.AddRange(node.Input.OutputList);
outputList.AddRange(GetRowBufferEntries(node.DefinedValues));
node.OutputList = outputList.ToArray();
return(node);
}
public virtual AlgebraNode VisitAggregateAlgebraNode(AggregateAlgebraNode node)
{
node.Input = VisitAlgebraNode(node.Input);
if (node.DefinedValues != null)
{
foreach (AggregatedValueDefinition definedValue in node.DefinedValues)
{
definedValue.Argument = VisitExpression(definedValue.Argument);
}
}
return(node);
}
public override AlgebraNode VisitAggregateAlgebraNode(AggregateAlgebraNode node)
{
ShowPlanElement inputElement = ConvertNode(node.Input);
PropertyListBuilder propertyListBuilder = new PropertyListBuilder();
AddRowBufferEntries(propertyListBuilder, Resources.ShowPlanGroupOutputList, node.OutputList);
AddStatistics(propertyListBuilder, node.StatisticsIterator);
AddDefinedValues(propertyListBuilder, node.DefinedValues);
if (node.Groups != null && node.Groups.Length > 0)
AddRowBufferEntries(propertyListBuilder, Resources.ShowPlanGroupGroupBy, node.Groups);
IList<ShowPlanProperty> properties = propertyListBuilder.ToList();
ShowPlanElement element = new ShowPlanElement(ShowPlanOperator.StreamAggregate, properties, inputElement);
_currentElement = element;
return node;
}
public override AlgebraNode VisitAggregateAlgebraNode(AggregateAlgebraNode node)
{
node.Input = VisitAlgebraNode(node.Input);
if (node.Input is NullScanAlgebraNode)
{
if (node.Groups != null && node.Groups.Length > 0)
{
// Grouped queries return nothing on empty input.
return(CreateNullScan(node.OutputList));
}
else
{
// Non-grouped aggregation. We return the result value of the aggregates
// executed against an empty input as a single row.
List <RowBufferEntry> outputList = new List <RowBufferEntry>();
List <ComputedValueDefinition> emptyValueList = new List <ComputedValueDefinition>();
foreach (AggregatedValueDefinition definedValue in node.DefinedValues)
{
IAggregator aggregator = definedValue.Aggregator;
aggregator.Init();
object emptyValue = aggregator.Terminate();
ComputedValueDefinition computedBufferedValue = new ComputedValueDefinition();
computedBufferedValue.Target = definedValue.Target;
computedBufferedValue.Expression = LiteralExpression.FromTypedValue(emptyValue, aggregator.ReturnType);
emptyValueList.Add(computedBufferedValue);
outputList.Add(computedBufferedValue.Target);
}
ConstantScanAlgebraNode constantScanAlgebraNode = new ConstantScanAlgebraNode();
constantScanAlgebraNode.DefinedValues = emptyValueList.ToArray();
constantScanAlgebraNode.OutputList = outputList.ToArray();
return(constantScanAlgebraNode);
}
}
return(node);
}
public override AlgebraNode VisitAggregateAlgebraNode(AggregateAlgebraNode node)
{
ShowPlanElement inputElement = ConvertNode(node.Input);
PropertyListBuilder propertyListBuilder = new PropertyListBuilder();
AddRowBufferEntries(propertyListBuilder, Resources.ShowPlanGroupOutputList, node.OutputList);
AddStatistics(propertyListBuilder, node.StatisticsIterator);
AddDefinedValues(propertyListBuilder, node.DefinedValues);
if (node.Groups != null && node.Groups.Length > 0)
{
AddRowBufferEntries(propertyListBuilder, Resources.ShowPlanGroupGroupBy, node.Groups);
}
IList <ShowPlanProperty> properties = propertyListBuilder.ToList();
ShowPlanElement element = new ShowPlanElement(ShowPlanOperator.StreamAggregate, properties, inputElement);
_currentElement = element;
return(node);
}
public override AlgebraNode VisitAggregateAlgebraNode(AggregateAlgebraNode node)
{
_willProduceAtMostOneRow = (node.Groups == null || node.Groups.Length == 0);
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 VisitAggregateAlgebraNode(AggregateAlgebraNode node)
{
node.Input = VisitAlgebraNode(node.Input);
if (node.Input is NullScanAlgebraNode)
{
if (node.Groups != null && node.Groups.Length > 0)
{
// Grouped queries return nothing on empty input.
return CreateNullScan(node.OutputList);
}
else
{
// Non-grouped aggregation. We return the result value of the aggregates
// executed against an empty input as a single row.
List<RowBufferEntry> outputList = new List<RowBufferEntry>();
List<ComputedValueDefinition> emptyValueList = new List<ComputedValueDefinition>();
foreach (AggregatedValueDefinition definedValue in node.DefinedValues)
{
IAggregator aggregator = definedValue.Aggregator;
aggregator.Init();
object emptyValue = aggregator.Terminate();
ComputedValueDefinition computedBufferedValue = new ComputedValueDefinition();
computedBufferedValue.Target = definedValue.Target;
computedBufferedValue.Expression = LiteralExpression.FromTypedValue(emptyValue, aggregator.ReturnType);
emptyValueList.Add(computedBufferedValue);
outputList.Add(computedBufferedValue.Target);
}
ConstantScanAlgebraNode constantScanAlgebraNode = new ConstantScanAlgebraNode();
constantScanAlgebraNode.DefinedValues = emptyValueList.ToArray();
constantScanAlgebraNode.OutputList = outputList.ToArray();
return constantScanAlgebraNode;
}
}
return node;
}
private static ResultAlgebraNode CreateAssertedSubquery(ResultAlgebraNode inputNode)
{
if (AstUtil.WillProduceAtMostOneRow(inputNode))
return inputNode;
RowBufferEntry inputEntry = inputNode.OutputList[0];
AggregatedValueDefinition countDefinedValue = new AggregatedValueDefinition();
countDefinedValue.Aggregate = new CountAggregateBinding("COUNT");
countDefinedValue.Aggregator = countDefinedValue.Aggregate.CreateAggregator(typeof(int));
countDefinedValue.Argument = LiteralExpression.FromInt32(0);
RowBufferEntry countDefinedValueEntry = new RowBufferEntry(countDefinedValue.Aggregator.ReturnType);
countDefinedValue.Target = countDefinedValueEntry;
RowBufferEntryExpression anyAggregateArgument = new RowBufferEntryExpression();
anyAggregateArgument.RowBufferEntry = inputEntry;
AggregatedValueDefinition anyDefinedValue = new AggregatedValueDefinition();
anyDefinedValue.Aggregate = new FirstAggregateBinding("ANY");
anyDefinedValue.Aggregator = anyDefinedValue.Aggregate.CreateAggregator(inputEntry.DataType);
anyDefinedValue.Argument = anyAggregateArgument;
RowBufferEntry anyDefinedValueEntry = new RowBufferEntry(inputEntry.DataType);
anyDefinedValue.Target = anyDefinedValueEntry;
AggregateAlgebraNode aggregateAlgebraNode = new AggregateAlgebraNode();
aggregateAlgebraNode.Input = inputNode.Input;
aggregateAlgebraNode.DefinedValues = new AggregatedValueDefinition[] { countDefinedValue, anyDefinedValue };
// CASE WHEN SubqueryCount > 1 THEN 0 ELSE NULL END
ExpressionBuilder expressionBuilder = new ExpressionBuilder();
expressionBuilder.Push(new RowBufferEntryExpression(countDefinedValueEntry));
expressionBuilder.Push(LiteralExpression.FromInt32(1));
expressionBuilder.PushBinary(BinaryOperator.Greater);
ExpressionNode whenExpression = expressionBuilder.Pop();
ExpressionNode thenExpression = LiteralExpression.FromInt32(0);
CaseExpression caseExpression = new CaseExpression();
caseExpression.WhenExpressions = new ExpressionNode[] { whenExpression };
caseExpression.ThenExpressions = new ExpressionNode[] { thenExpression };
expressionBuilder.Push(caseExpression);
ExpressionNode predicate = expressionBuilder.Pop();
AssertAlgebraNode assertAlgebraNode = new AssertAlgebraNode();
assertAlgebraNode.Input = aggregateAlgebraNode;
assertAlgebraNode.Predicate = predicate;
assertAlgebraNode.AssertionType = AssertionType.MaxOneRow;
ResultAlgebraNode resultAlgebraNode = new ResultAlgebraNode();
resultAlgebraNode.Input = assertAlgebraNode;
resultAlgebraNode.OutputList = new RowBufferEntry[] { anyDefinedValueEntry };
resultAlgebraNode.ColumnNames = inputNode.ColumnNames;
return resultAlgebraNode;
}
public override AlgebraNode VisitAggregateAlgebraNode(AggregateAlgebraNode node)
{
_willProduceAtMostOneRow = (node.Groups == null || node.Groups.Length == 0);
return node;
}
private static ResultAlgebraNode CreateAssertedSubquery(ResultAlgebraNode inputNode)
{
if (AstUtil.WillProduceAtMostOneRow(inputNode))
{
return(inputNode);
}
RowBufferEntry inputEntry = inputNode.OutputList[0];
AggregatedValueDefinition countDefinedValue = new AggregatedValueDefinition();
countDefinedValue.Aggregate = new CountAggregateBinding("COUNT");
countDefinedValue.Aggregator = countDefinedValue.Aggregate.CreateAggregator(typeof(int));
countDefinedValue.Argument = LiteralExpression.FromInt32(0);
RowBufferEntry countDefinedValueEntry = new RowBufferEntry(countDefinedValue.Aggregator.ReturnType);
countDefinedValue.Target = countDefinedValueEntry;
RowBufferEntryExpression anyAggregateArgument = new RowBufferEntryExpression();
anyAggregateArgument.RowBufferEntry = inputEntry;
AggregatedValueDefinition anyDefinedValue = new AggregatedValueDefinition();
anyDefinedValue.Aggregate = new FirstAggregateBinding("ANY");
anyDefinedValue.Aggregator = anyDefinedValue.Aggregate.CreateAggregator(inputEntry.DataType);
anyDefinedValue.Argument = anyAggregateArgument;
RowBufferEntry anyDefinedValueEntry = new RowBufferEntry(inputEntry.DataType);
anyDefinedValue.Target = anyDefinedValueEntry;
AggregateAlgebraNode aggregateAlgebraNode = new AggregateAlgebraNode();
aggregateAlgebraNode.Input = inputNode.Input;
aggregateAlgebraNode.DefinedValues = new AggregatedValueDefinition[] { countDefinedValue, anyDefinedValue };
// CASE WHEN SubqueryCount > 1 THEN 0 ELSE NULL END
ExpressionBuilder expressionBuilder = new ExpressionBuilder();
expressionBuilder.Push(new RowBufferEntryExpression(countDefinedValueEntry));
expressionBuilder.Push(LiteralExpression.FromInt32(1));
expressionBuilder.PushBinary(BinaryOperator.Greater);
ExpressionNode whenExpression = expressionBuilder.Pop();
ExpressionNode thenExpression = LiteralExpression.FromInt32(0);
CaseExpression caseExpression = new CaseExpression();
caseExpression.WhenExpressions = new ExpressionNode[] { whenExpression };
caseExpression.ThenExpressions = new ExpressionNode[] { thenExpression };
expressionBuilder.Push(caseExpression);
ExpressionNode predicate = expressionBuilder.Pop();
AssertAlgebraNode assertAlgebraNode = new AssertAlgebraNode();
assertAlgebraNode.Input = aggregateAlgebraNode;
assertAlgebraNode.Predicate = predicate;
assertAlgebraNode.AssertionType = AssertionType.MaxOneRow;
ResultAlgebraNode resultAlgebraNode = new ResultAlgebraNode();
resultAlgebraNode.Input = assertAlgebraNode;
resultAlgebraNode.OutputList = new RowBufferEntry[] { anyDefinedValueEntry };
resultAlgebraNode.ColumnNames = inputNode.ColumnNames;
return(resultAlgebraNode);
}
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 VisitAggregateAlgebraNode(AggregateAlgebraNode node)
{
_xmlWriter.WriteStartElement("aggregateAlgebraNode");
WriteAstNode("input", node.Input);
WriteRowBufferEntries("groups", node.Groups);
//WriteAstNodes("aggregates", node.Aggregates);
_xmlWriter.WriteEndElement();
return node;
}
public override AlgebraNode VisitAggregateAlgebraNode(AggregateAlgebraNode node)
{
StreamAggregateIterator streamAggregateIterator = new StreamAggregateIterator();
streamAggregateIterator.RowBuffer = new object[node.OutputList.Length];
streamAggregateIterator.Input = ConvertAlgebraNode(node.Input);
streamAggregateIterator.InputOutput = GetIteratorOutput(0, node.Input.OutputList, node.OutputList);
BoundRowBufferEntrySet boundRowBufferEntrySet = new BoundRowBufferEntrySet(streamAggregateIterator.Input.RowBuffer, node.Input.OutputList);
if (node.Groups == null)
{
streamAggregateIterator.GroupByEntries = new IteratorInput[0];
streamAggregateIterator.DefinedValues = GetDefinedValues(node.OutputList, node.DefinedValues, boundRowBufferEntrySet);
}
else
{
streamAggregateIterator.GroupByEntries = GetIteratorInput(node.Input.OutputList, node.Groups);
streamAggregateIterator.DefinedValues = GetDefinedValues(node.OutputList, node.DefinedValues, boundRowBufferEntrySet);
}
SetLastIterator(node, streamAggregateIterator);
return node;
}
public virtual AlgebraNode VisitAggregateAlgebraNode(AggregateAlgebraNode node)
{
node.Input = VisitAlgebraNode(node.Input);
if (node.DefinedValues != null)
{
foreach (AggregatedValueDefinition definedValue in node.DefinedValues)
definedValue.Argument = VisitExpression(definedValue.Argument);
}
return node;
}
