internal void InsertVertexNode(int index, DLinqQueryNode node)
{
if (index == -1)
{
this.m_vertexNodes.Add(node);
}
else
{
this.m_vertexNodes.Insert(index, node);
}
}
/// <summary>
/// Helper for CodeShowVisit: do not revisit a node twice.
/// </summary>
/// <param name="plan">Return plan here.</param>
/// <param name="n">Node to explain.</param>
/// <param name="visited">Set of nodes already visited.</param>
private void CodeShowVisit(StringBuilder plan, DLinqQueryNode n, HashSet <DLinqQueryNode> visited)
{
if (visited.Contains(n))
{
return;
}
visited.Add(n);
foreach (DLinqQueryNode c in n.Children)
{
CodeShowVisit(plan, c, visited);
}
ExplainNode(plan, n);
}
public QueryNodeInfo(Expression queryExpression,
bool isQueryOperator,
params QueryNodeInfo[] children)
{
this.QueryExpression = queryExpression;
this.IsQueryOperator = isQueryOperator;
this.Children = new List<NodeInfoEdge>(children.Length);
foreach (QueryNodeInfo childInfo in children)
{
NodeInfoEdge edge = new NodeInfoEdge(this, childInfo);
this.Children.Add(edge);
childInfo.Parents.Add(edge);
}
this.Parents = new List<NodeInfoEdge>();
this.QueryNode = null;
}
internal override XmlElement CreateElem(XmlDocument queryDoc)
{
XmlElement managerElem = queryDoc.CreateElement("DynamicManager");
XmlElement elem = queryDoc.CreateElement("Type");
elem.InnerText = Convert.ToString(this.ManagerType.ToString());
managerElem.AppendChild(elem);
elem = queryDoc.CreateElement("SampleRate");
elem.InnerText = Convert.ToString(this.m_sampleRate);
managerElem.AppendChild(elem);
elem = queryDoc.CreateElement("VertexId");
DLinqQueryNode node = this.m_vertexNodes[0];
if (node.SuperNode != null)
{
node = node.SuperNode;
}
elem.InnerText = Convert.ToString(node.m_uniqueId);
managerElem.AppendChild(elem);
return(managerElem);
}
internal virtual string AddVertexCode(DLinqQueryNode node,
CodeMemberMethod vertexMethod,
string[] readerNames,
string[] writerNames)
{
switch (node.NodeType)
{
case QueryNodeType.InputTable:
{
return(this.Visit((DLinqInputNode)node, vertexMethod, readerNames, writerNames));
}
case QueryNodeType.OutputTable:
{
return(this.Visit((DLinqOutputNode)node, vertexMethod, readerNames, writerNames));
}
case QueryNodeType.Aggregate:
{
return(this.Visit((DLinqAggregateNode)node, vertexMethod, readerNames, writerNames));
}
case QueryNodeType.Select:
case QueryNodeType.SelectMany:
{
return(this.Visit((DLinqSelectNode)node, vertexMethod, readerNames, writerNames));
}
case QueryNodeType.Where:
{
return(this.Visit((DLinqWhereNode)node, vertexMethod, readerNames, writerNames));
}
case QueryNodeType.Distinct:
{
return(this.Visit((DLinqDistinctNode)node, vertexMethod, readerNames, writerNames));
}
case QueryNodeType.BasicAggregate:
{
return(this.Visit((DLinqBasicAggregateNode)node, vertexMethod, readerNames, writerNames));
}
case QueryNodeType.GroupBy:
{
return(this.Visit((DLinqGroupByNode)node, vertexMethod, readerNames, writerNames));
}
case QueryNodeType.OrderBy:
{
return(this.Visit((DLinqOrderByNode)node, vertexMethod, readerNames, writerNames));
}
case QueryNodeType.Skip:
case QueryNodeType.SkipWhile:
case QueryNodeType.Take:
case QueryNodeType.TakeWhile:
{
return(this.Visit((DLinqPartitionOpNode)node, vertexMethod, readerNames, writerNames));
}
case QueryNodeType.Contains:
{
return(this.Visit((DLinqContainsNode)node, vertexMethod, readerNames, writerNames));
}
case QueryNodeType.Join:
case QueryNodeType.GroupJoin:
{
return(this.Visit((DLinqJoinNode)node, vertexMethod, readerNames, writerNames));
}
case QueryNodeType.Union:
case QueryNodeType.Intersect:
case QueryNodeType.Except:
{
return(this.Visit((DLinqSetOperationNode)node, vertexMethod, readerNames, writerNames));
}
case QueryNodeType.Concat:
{
return(this.Visit((DLinqConcatNode)node, vertexMethod, readerNames, writerNames));
}
case QueryNodeType.Zip:
{
return(this.Visit((DLinqZipNode)node, vertexMethod, readerNames, writerNames));
}
case QueryNodeType.Super:
{
return(this.Visit((DLinqSuperNode)node, vertexMethod, readerNames, writerNames));
}
case QueryNodeType.RangePartition:
{
return(this.Visit((DLinqRangePartitionNode)node, vertexMethod, readerNames, writerNames));
}
case QueryNodeType.HashPartition:
{
return(this.Visit((DLinqHashPartitionNode)node, vertexMethod, readerNames, writerNames));
}
case QueryNodeType.Merge:
{
return(this.Visit((DLinqMergeNode)node, vertexMethod, readerNames, writerNames));
}
case QueryNodeType.Apply:
{
return(this.Visit((DLinqApplyNode)node, vertexMethod, readerNames, writerNames));
}
case QueryNodeType.Fork:
{
return(this.Visit((DLinqForkNode)node, vertexMethod, readerNames, writerNames));
}
case QueryNodeType.Tee:
{
return(this.Visit((DLinqTeeNode)node, vertexMethod, readerNames, writerNames));
}
case QueryNodeType.Dynamic:
{
return(this.Visit((DLinqDynamicNode)node, vertexMethod, readerNames, writerNames));
}
case QueryNodeType.Dummy:
{
return(this.Visit((DLinqDummyNode)node, vertexMethod, readerNames, writerNames));
}
default:
{
throw new DryadLinqException("Internal error: unhandled node type " + node.NodeType);
}
}
}
/// <summary>
/// Explain one query node.
/// </summary>
/// <param name="plan">Return plan here.</param>
/// <param name="n">Node to explain.</param>
internal static void ExplainNode(StringBuilder plan, DLinqQueryNode n)
{
if (n is DLinqTeeNode || n is DLinqOutputNode ||
n is DLinqDoWhileNode || n is DLinqDummyNode)
{
return;
}
else if (n is DLinqInputNode)
{
plan.AppendLine("Input:");
plan.Append("\t");
n.BuildString(plan);
plan.AppendLine();
return;
}
plan.Append(n.m_vertexEntryMethod);
plan.AppendLine(":");
HashSet <DLinqQueryNode> allchildren = new HashSet <DLinqQueryNode>();
if (n is DLinqSuperNode)
{
DLinqSuperNode sn = n as DLinqSuperNode;
List <DLinqQueryNode> tovisit = new List <DLinqQueryNode>();
tovisit.Add(sn.RootNode);
while (tovisit.Count > 0)
{
DLinqQueryNode t = tovisit[0];
tovisit.RemoveAt(0);
if (!(t is DLinqSuperNode))
{
allchildren.Add(t);
}
foreach (DLinqQueryNode tc in t.Children)
{
if (!allchildren.Contains(tc) && sn.Contains(tc))
{
tovisit.Add(tc);
}
}
}
}
else
{
allchildren.Add(n);
}
foreach (DLinqQueryNode nc in allchildren.Reverse())
{
Expression expression = null; // expression to print
List <string> additional = new List <string>(); // additional arguments to print
int argsToSkip = 0;
string methodname = nc.OpName;
plan.Append("\t");
if (nc is DLinqMergeNode)
{
expression = ((DLinqMergeNode)nc).ComparerExpression;
}
else if (nc is DLinqHashPartitionNode)
{
DLinqHashPartitionNode hp = (DLinqHashPartitionNode)nc;
expression = hp.KeySelectExpression;
additional.Add(hp.NumberOfPartitions.ToString());
}
else if (nc is DLinqGroupByNode)
{
DLinqGroupByNode gb = (DLinqGroupByNode)nc;
expression = gb.KeySelectExpression;
if (gb.ElemSelectExpression != null)
{
additional.Add(DryadLinqExpression.Summarize(gb.ElemSelectExpression));
}
if (gb.ResSelectExpression != null)
{
additional.Add(DryadLinqExpression.Summarize(gb.ResSelectExpression));
}
if (gb.ComparerExpression != null)
{
additional.Add(DryadLinqExpression.Summarize(gb.ComparerExpression));
}
if (gb.SeedExpression != null)
{
additional.Add(DryadLinqExpression.Summarize(gb.SeedExpression));
}
if (gb.AccumulatorExpression != null)
{
additional.Add(DryadLinqExpression.Summarize(gb.AccumulatorExpression));
}
}
else if (nc is DLinqOrderByNode)
{
DLinqOrderByNode ob = (DLinqOrderByNode)nc;
expression = ob.KeySelectExpression;
if (ob.ComparerExpression != null)
{
additional.Add(DryadLinqExpression.Summarize(ob.ComparerExpression));
}
}
else if (nc is DLinqWhereNode)
{
expression = ((DLinqWhereNode)nc).WhereExpression;
}
else if (nc is DLinqSelectNode)
{
DLinqSelectNode s = (DLinqSelectNode)nc;
expression = s.SelectExpression;
if (s.ResultSelectExpression != null)
{
additional.Add(DryadLinqExpression.Summarize(s.ResultSelectExpression));
}
}
else if (nc is DLinqAggregateNode)
{
DLinqAggregateNode a = (DLinqAggregateNode)nc;
expression = a.FuncLambda;
if (a.SeedExpression != null)
{
additional.Add(DryadLinqExpression.Summarize(a.SeedExpression));
}
if (a.ResultLambda != null)
{
additional.Add(DryadLinqExpression.Summarize(a.ResultLambda));
}
}
else if (nc is DLinqPartitionOpNode)
{
expression = ((DLinqPartitionOpNode)nc).ControlExpression;
}
else if (nc is DLinqJoinNode)
{
DLinqJoinNode j = (DLinqJoinNode)nc;
expression = j.OuterKeySelectorExpression;
additional.Add(DryadLinqExpression.Summarize(j.InnerKeySelectorExpression));
additional.Add(DryadLinqExpression.Summarize(j.ResultSelectorExpression));
if (j.ComparerExpression != null)
{
additional.Add(DryadLinqExpression.Summarize(j.ComparerExpression));
}
}
else if (nc is DLinqDistinctNode)
{
expression = ((DLinqDistinctNode)nc).ComparerExpression;
}
else if (nc is DLinqContainsNode)
{
DLinqContainsNode c = (DLinqContainsNode)nc;
expression = c.ValueExpression;
if (c.ComparerExpression != null)
{
additional.Add(DryadLinqExpression.Summarize(c.ComparerExpression));
}
}
else if (nc is DLinqBasicAggregateNode)
{
expression = ((DLinqBasicAggregateNode)nc).SelectExpression;
}
else if (nc is DLinqConcatNode)
// nothing to do
{
}
else if (nc is DLinqSetOperationNode)
{
expression = ((DLinqSetOperationNode)nc).ComparerExpression;
}
else if (nc is DLinqRangePartitionNode)
{
DLinqRangePartitionNode r = (DLinqRangePartitionNode)nc;
expression = r.CountExpression;
// TODO: there's some other possible interesting info
}
else if (nc is DLinqApplyNode)
{
expression = ((DLinqApplyNode)nc).LambdaExpression;
}
else if (nc is DLinqForkNode)
{
expression = ((DLinqForkNode)nc).ForkLambda;
}
else if (nc is DLinqTeeNode)
{
// nothing
}
else if (nc is DLinqDynamicNode)
{
// nothing
}
else
{
expression = nc.QueryExpression;
}
if (expression is MethodCallExpression)
{
MethodCallExpression mc = (MethodCallExpression)expression;
methodname = mc.Method.Name; // overwrite methodname
// determine which arguments to skip
#region LINQMETHODS
switch (mc.Method.Name)
{
case "Aggregate":
case "AggregateAsQuery":
case "Select":
case "LongSelect":
case "SelectMany":
case "LongSelectMany":
case "OfType":
case "Where":
case "LongWhere":
case "First":
case "FirstOrDefault":
case "FirstAsQuery":
case "Single":
case "SingleOrDefault":
case "SingleAsQuery":
case "Last":
case "LastOrDefault":
case "LastAsQuery":
case "Distinct":
case "Any":
case "AnyAsQuery":
case "All":
case "AllAsQuery":
case "Count":
case "CountAsQuery":
case "LongCount":
case "LongCountAsQuery":
case "Sum":
case "SumAsQuery":
case "Min":
case "MinAsQuery":
case "Max":
case "MaxAsQuery":
case "Average":
case "AverageAsQuery":
case "GroupBy":
case "OrderBy":
case "OrderByDescending":
case "ThenBy":
case "ThenByDescending":
case "Take":
case "TakeWhile":
case "LongTakeWhile":
case "Skip":
case "SkipWhile":
case "LongSkipWhile":
case "Contains":
case "ContainsAsQuery":
case "Reverse":
case "Merge":
case "HashPartition":
case "RangePartition":
case "Fork":
case "ForkChoose":
case "AssumeHashPartition":
case "AssumeRangePartition":
case "AssumeOrderBy":
case "ToPartitionedTableLazy":
case "AddCacheEntry":
case "SlidingWindow":
case "ApplyWithPartitionIndex":
case "DoWhile":
argsToSkip = 1;
break;
case "Join":
case "GroupJoin":
case "Concat":
case "MultiConcat":
case "Union":
case "Intersect":
case "Except":
case "SequenceEqual":
case "SequenceEqualAsQuery":
case "Zip":
argsToSkip = 2;
break;
case "Apply":
case "ApplyPerPartition":
if (mc.Arguments.Count < 3)
{
argsToSkip = 1;
}
else
{
argsToSkip = 2;
}
break;
default:
throw DryadLinqException.Create(DryadLinqErrorCode.OperatorNotSupported,
String.Format(SR.OperatorNotSupported, mc.Method.Name),
expression);
}
#endregion
plan.Append(methodname);
plan.Append("(");
int argno = 0;
foreach (var arg in mc.Arguments)
{
argno++;
if (argno <= argsToSkip)
{
continue;
}
if (argno > argsToSkip + 1)
{
plan.Append(",");
}
plan.Append(DryadLinqExpression.Summarize(arg));
}
plan.AppendLine(")");
}
else
{
// expression is not methodcall
plan.Append(methodname);
plan.Append("(");
if (expression != null)
{
plan.Append(DryadLinqExpression.Summarize(expression));
}
foreach (string e in additional)
{
plan.Append(",");
plan.Append(e);
}
plan.AppendLine(")");
}
}
}
/// <summary>
/// Create a dynamic manager with a single parameter node.
/// </summary>
/// <param name="type">Type of manager to create.</param>
/// <param name="node">Node that the manager depends on.</param>
internal DynamicManager(DynamicManagerType type, DLinqQueryNode node)
: this(type)
{
this.m_vertexNodes.Add(node);
}
internal DynamicRangeDistributor(DLinqQueryNode node)
: base(DynamicManagerType.RangeDistributor, node)
{
//@@TODO[P2]: This sample rate used here should really be its own constant.
this.m_sampleRate = DryadLinqSampler.SAMPLE_RATE;
}
internal override DLinqQueryNode CreatePartitionNode(LambdaExpression keySel, DLinqQueryNode child)
{
Expression comparerExpr = Expression.Constant(this.m_comparer, typeof(IEqualityComparer <TKey>));
return(new DLinqHashPartitionNode(keySel, comparerExpr, this.Count, child.QueryExpression, child));
}
internal override DLinqQueryNode CreatePartitionNode(LambdaExpression keySel, DLinqQueryNode child)
{
Expression keysExpr = Expression.Constant(this.m_partitionKeys);
Expression comparerExpr = Expression.Constant(this.m_comparer, typeof(IComparer <TKey>));
Expression isDescendingExpr = Expression.Constant(this.m_isDescending);
return(new DLinqRangePartitionNode(keySel, null, keysExpr, comparerExpr, isDescendingExpr, null, child.QueryExpression, child));
}
internal override DLinqQueryNode CreatePartitionNode(LambdaExpression keySel, DLinqQueryNode child)
{
throw new DryadLinqException(DryadLinqErrorCode.CannotCreatePartitionNodeRandom,
SR.CannotCreatePartitionNodeRandom);
}
internal abstract DLinqQueryNode CreatePartitionNode(LambdaExpression keySelector, DLinqQueryNode child);
