Node

System\Data\Mapping\FunctionImportMappingComposable.cs (20)

82private Node m_internalTreeNode; 94internal Node GetInternalTree(Command targetIqtCommand, IList<Node> targetIqtArguments) 109var rootProject = itree.Root; // PhysicalProject(RelInput) 113var rootInput = rootProject.Child0; // the RelInput in PhysicalProject(RelInput) 119Node relNode = rootInput; 131Node varRefNode = itree.CreateNode(itree.CreateVarRefOp(relVar)); 132Node castNode = itree.CreateNode(itree.CreateSoftCastOp(expectedElementType), varRefNode); 133Node varDefListNode = itree.CreateVarDefListNode(castNode, out relVar); 146Dictionary<string, Node> viewArguments = new Dictionary<string, Node>(m_commandParameters.Length); 150var argumentNode = targetIqtArguments[i]; 172private Dictionary<string, Node> m_viewArguments; 174private FunctionViewOpCopier(Command cmd, Dictionary<string, Node> viewArguments) 180internal static Node Copy(Command cmd, Node viewNode, Dictionary<string, Node> viewArguments) 186public override Node Visit(VarRefOp op, Node n) 195Node argNode;

System\Data\Mapping\ViewGeneration\GeneratedView.cs (2)

172private Node m_internalTreeNode; //we cache IQTs for Query Views since that is the one query stack works of. 206internal Node GetInternalTree(Command targetIqtCommand)

System\Data\Query\InternalTrees\AncillaryOps.cs (4)

53internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); } 62internal override TResultType Accept<TResultType>(BasicOpVisitorOfT<TResultType> v, Node n) { return v.Visit(this, n); } 88internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); } 97internal override TResultType Accept<TResultType>(BasicOpVisitorOfT<TResultType> v, Node n) { return v.Visit(this, n); }

System\Data\Query\InternalTrees\Command.cs (68)

33private Node m_root; 98internal Node Root { get { return m_root; } set { m_root = value; } } 528internal Node CreateNode(Op op) 530return this.CreateNode(op, new List<Node>()); 539internal Node CreateNode(Op op, Node arg1) 541List<Node> l = new List<Node>(); 553internal Node CreateNode(Op op, Node arg1, Node arg2) 555List<Node> l = new List<Node>(); 568internal Node CreateNode(Op op, Node arg1, Node arg2, Node arg3) 570List<Node> l = new List<Node>(); 581internal Node CreateNode(Op op, IList<Node> args) 583return new Node(m_nextNodeId++, op, new List<Node>(args)); 592internal Node CreateNode(Op op, List<Node> args) 1058internal Node CreateVarDefNode(Node definingExpr, out Var computedVar) 1065Node varDefNode = this.CreateNode(varDefOp, definingExpr); 1076internal Node CreateVarDefListNode(Node definingExpr, out Var computedVar) 1078Node varDefNode = this.CreateVarDefNode(definingExpr, out computedVar); 1080Node varDefListNode = this.CreateNode(op, varDefNode); 1515internal NodeInfo GetNodeInfo(Node n) 1525internal ExtendedNodeInfo GetExtendedNodeInfo(Node n) 1533internal void RecomputeNodeInfo(Node n) 1545internal KeyVec PullupKeys(Node n) 1599IList<Node> inputNodes, IList<Var> inputVars, 1600out Node resultNode, out IList<Var> resultVars) 1621Node unionAllNode = inputNodes[0]; 1655internal void BuildUnionAllLadder(IList<Node> inputNodes, IList<Var> inputVars, 1656out Node resultNode, out Var resultVar) 1681internal Node BuildProject(Node inputNode, IEnumerable<Var> inputVars, 1682IEnumerable<Node> computedExpressions) 1687Node varDefListNode = this.CreateNode(varDefListOp); 1689foreach (Node expr in computedExpressions) 1694Node varDefNode = this.CreateNode(varDefOp, expr); 1697Node projectNode = this.CreateNode( 1714internal Node BuildProject(Node input, Node computedExpression, out Var projectVar) 1716Node projectNode = BuildProject(input, new Var[] { }, new Node[] { computedExpression }); 1738internal void BuildOfTypeTree(Node inputNode, Var inputVar, TypeUsage desiredType, bool includeSubtypes, 1739out Node resultNode, out Var resultVar) 1742Node predicate = this.CreateNode(isOfOp, this.CreateNode(this.CreateVarRefOp(inputVar))); 1743Node filterNode = this.CreateNode(this.CreateFilterOp(), inputNode, predicate); 1756internal Node BuildFakeTreatProject(Node inputNode, Var inputVar, TypeUsage desiredType, out Var resultVar) 1758Node treatNode = this.CreateNode(this.CreateFakeTreatOp(desiredType), 1760Node resultNode = this.BuildProject(inputNode, treatNode, out resultVar); 1772internal Node BuildComparison(OpType opType, Node arg0, Node arg1) 1787Node newNode = this.CreateNode(this.CreateComparisonOp(opType), arg0, arg1); 1797internal Node BuildCollect(Node relOpNode, Var relOpVar) 1799Node physicalProjectNode = this.CreateNode(this.CreatePhysicalProjectOp(relOpVar), relOpNode); 1801Node collectNode = this.CreateNode(this.CreateCollectOp(collectOpType), physicalProjectNode);

System\Data\Query\InternalTrees\Dump.cs (34)

System\Data\Query\InternalTrees\NodeCounter.cs (3)

29internal static int Count(Node subTree) 41protected override int VisitDefault(Node n) 44foreach (Node child in n.Children)

System\Data\Query\InternalTrees\NodeInfo.cs (36)

System\Data\Query\InternalTrees\Nodes.cs (10)

26private List<Node> m_children; 41internal Node(int nodeId, Op op, List<Node> children) 54internal Node(Op op, params Node[] children) 55: this(-1, op, new List<Node>(children)) 69internal List<Node> Children { get { return m_children; } } 79internal Node Child0 { get { return m_children[0]; } set { m_children[0] = value; } } 88internal Node Child1 { get { return m_children[1]; } set { m_children[1] = value; } } 97internal Node Child2 { get { return m_children[2]; } set { m_children[2] = value; } } 101internal Node Child3 { get { return m_children[3]; } /* commented out because of fxcop - there are no upstream callers -- set { m_children[3] = value; }*/ } 117internal bool IsEquivalent(Node other)

System\Data\Query\InternalTrees\OpCopier.cs (152)

System\Data\Query\InternalTrees\Ops.cs (2)

480internal virtual void Accept(BasicOpVisitor v, Node n) 492internal virtual TResultType Accept<TResultType>(BasicOpVisitorOfT<TResultType> v, Node n)

System\Data\Query\InternalTrees\PhysicalOps.cs (6)

54internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); } 63internal override TResultType Accept<TResultType>(BasicOpVisitorOfT<TResultType> v, Node n) { return v.Visit(this, n); } 266internal override void Accept(BasicOpVisitor v, Node n) 278internal override TResultType Accept<TResultType>(BasicOpVisitorOfT<TResultType> v, Node n) 318internal override void Accept(BasicOpVisitor v, Node n) { v.Visit(this, n); } 327internal override TResultType Accept<TResultType>(BasicOpVisitorOfT<TResultType> v, Node n) { return v.Visit(this, n); }

System\Data\Query\InternalTrees\RelOps.cs (44)

System\Data\Query\InternalTrees\Rule.cs (11)

35internal delegate bool ProcessNodeDelegate(RuleProcessingContext context, Node subTree, out Node newSubTree); 69internal abstract bool Match(Node node); 79internal bool Apply(RuleProcessingContext ruleProcessingContext, Node node, out Node newNode) 128internal override bool Match(Node node) 142private Node m_pattern; 151internal PatternMatchRule(Node pattern, ProcessNodeDelegate processDelegate) 161private bool Match(Node pattern, Node original) 177internal override bool Match(Node node)

System\Data\Query\InternalTrees\RuleProcessor.cs (18)

45private static bool ApplyRulesToNode(RuleProcessingContext context, ReadOnlyCollection<ReadOnlyCollection<InternalTrees.Rule>> rules, Node currentNode, out Node newNode) 85private Node ApplyRulesToSubtree(RuleProcessingContext context, 87Node subTreeRoot, Node parent, int childIndexInParent) 131Node newSubTreeRoot; 155internal Node ApplyRulesToSubtree(RuleProcessingContext context, ReadOnlyCollection<ReadOnlyCollection<InternalTrees.Rule>> rules, Node subTreeRoot) 168public Node m_subTreeRoot; 170private Node m_parent; 176internal SubTreeId(RuleProcessingContext context, Node node, Node parent, int childIndex) 209internal delegate void OpDelegate(RuleProcessingContext context, Node node); 227internal virtual void PreProcess(Node node) 237internal virtual void PreProcessSubTree(Node node) 247internal virtual void PostProcess(Node node, Rule rule) 256internal virtual void PostProcessSubTree(Node node) 265internal virtual int GetHashCode(Node node)

System\Data\Query\InternalTrees\ScalarOps.cs (64)

System\Data\Query\InternalTrees\Visitors.cs (165)

System\Data\Query\PlanCompiler\AggregatePushdown.cs (90)

37internal delegate bool TryGetValue(Node key, out Node value); 47private readonly Node _definingGroupByNode; 48private HashSet<KeyValuePair<Node, Node>> _candidateAggregateNodes; 58internal GroupAggregateVarInfo(Node defingingGroupNode, Var groupAggregateVar) 73internal HashSet<KeyValuePair<Node, Node>> CandidateAggregateNodes 79_candidateAggregateNodes = new HashSet<KeyValuePair<Node, Node>>(); 99internal Node DefiningGroupNode 120private readonly Node _computation; 131internal GroupAggregateVarRefInfo(GroupAggregateVarInfo groupAggregateVarInfo, Node computation, bool isUnnested) 145internal Node Computation 199internal void Add(Var var, GroupAggregateVarInfo groupAggregateVarInfo, Node computationTemplate, bool isUnnested) 214internal void Add(Var var, GroupAggregateVarInfo groupAggregateVarInfo, Node computationTemplate, bool isUnnested, EdmMember property) 322Node subtree, 327out Node templateNode, 332Node inputNode = subtree; 390public override Node Visit(VarRefOp op, Node n) 403public override Node Visit(PropertyOp op, Node n) 428private Node VisitCollect(Node n) 431Node currentNode = n.Child0; 432Dictionary<Var, Node> constantDefinitions = new Dictionary<Var, Node>(); 441foreach (Node definitionNode in currentNode.Child1.Children) 482Node computationTemplate = TranslateOverGroupAggregateVar(outputVar, null); 489Node constantDefinitionNode; 505private static bool IsConstant(Node node) 507Node currentNode = node; 526private Node TranslateOverGroupAggregateVar(Var var, EdmMember property) 553Node computationTemplate = groupAggregateVarRefInfo.Computation; 570protected override Node VisitDefault(Node n) 572List<Node> newChildren = new List<Node>(n.Children.Count); 576Node processedChild = VisitNode(n.Children[i]); 600protected override Node VisitRelOpDefault(RelOp op, Node n) 605public override Node Visit(AggregateOp op, Node n) 610public override Node Visit(CollectOp op, Node n) 615public override Node Visit(ElementOp op, Node n) 635private readonly Dictionary<Node, Node> _childToParent = new Dictionary<Node, Node>(); 677public override void Visit(VarDefOp op, Node n) 681Node definingNode = n.Child0; 685Node templateNode; 696Node argumentNode = definingNode.Children[i]; 713public override void Visit(GroupByIntoOp op, Node n) 716foreach (Node child in n.Child3.Children) 737public override void Visit(UnnestOp op, Node n) 758public override void Visit(FunctionOp op, Node n) 767Node argumentNode = n.Child0; 770Node templateNode; 775referencedGroupAggregateVarInfo.CandidateAggregateNodes.Add(new KeyValuePair<Node, Node>(n, templateNode)); 786protected override void VisitDefault(Node n) 789foreach (Node child in n.Children) 813internal static bool IsVarRefOverGivenVar(Node node, Var var) 866foreach (KeyValuePair<Node, Node> candidate in groupAggregateVarInfo.CandidateAggregateNodes) 887KeyValuePair<Node, Node> candidate, 890IList<Node> functionAncestors; 891IList<Node> groupByAncestors; 892Node definingGroupNode = groupAggregateVarInfo.DefiningGroupNode; 911Node argumentNode = OpCopier.Copy(m_command, candidate.Value); 917Node newFunctionDefiningNode = m_command.CreateNode( 922Node varDefNode = m_command.CreateVarDefNode(newFunctionDefiningNode, out newFunctionVar); 932Node groupByAncestor = groupByAncestors[i]; 951private static bool AreAllNodesSupportedForPropagation(IList<Node> nodes) 953foreach (Node node in nodes) 973private void FindPathsToLeastCommonAncestor(Node node1, Node node2, out IList<Node> ancestors1, out IList<Node> ancestors2) 1002private IList<Node> FindAncestors(Node node) 1004List<Node> ancestors = new List<Node>(); 1005Node currentNode = node; 1006Node ancestor;

System\Data\Query\PlanCompiler\CodeGen.cs (4)

92this.m_subCommands = new List<Node>(new Node[] { this.Command.Root }); 126foreach (Node subCommand in m_subCommands) 147private List<Node> m_subCommands;

System\Data\Query\PlanCompiler\CTreeGenerator.cs (85)

System\Data\Query\PlanCompiler\ITreeGenerator.cs (256)

System\Data\Query\PlanCompiler\JoinElimination.cs (18)

55private Dictionary<Node, Node> m_joinGraphUnnecessaryMap = new Dictionary<Node,Node>(); 99private bool NeedsJoinGraph(Node joinNode) 109private Node ProcessJoinGraph(Node joinNode) 116Dictionary<Node, Node> processedNodes; 117Node newNode = joinGraph.DoJoinElimination(out remappedVars, out processedNodes); 125foreach (Node n in processedNodes.Keys) 161private Node VisitDefaultForAllNodes(Node n) 180protected override Node VisitDefault(Node n) 195protected override Node VisitJoinOp(JoinBaseOp op, Node joinNode) 197Node newNode;

System\Data\Query\PlanCompiler\JoinGraph.cs (75)

System\Data\Query\PlanCompiler\KeyPullup.cs (11)

61internal KeyVec GetKeys(Node node) 84protected override void VisitChildren(Node n) 86foreach (Node chi in n.Children) 105protected override void VisitRelOpDefault(RelOp op, Node n) 117public override void Visit(ScanTableOp op, Node n) 133public override void Visit(ProjectOp op, Node n) 217public override void Visit(UnionAllOp op, Node n) 238Node branchNode = n.Children[i]; 279Node branchNode = n.Children[i]; 283List<Node> varDefNodes = new List<Node>();

System\Data\Query\PlanCompiler\NestPullup.cs (189)

System\Data\Query\PlanCompiler\NominalTypeEliminator.cs (217)

System\Data\Query\PlanCompiler\Normalizer.cs (29)

83public override Node Visit(ExistsOp op, Node n) 98private Node BuildDummyProjectForExists(Node child) 101Node projectNode = m_command.BuildProject( 114private Node BuildUnnest(Node collectionNode) 120Node varDefNode = m_command.CreateVarDefNode(collectionNode, out newVar); 122Node unnestNode = m_command.CreateNode(unnestOp, varDefNode); 133private Node VisitCollectionFunction(FunctionOp op, Node n) 137Node unnestNode = BuildUnnest(n); 140Node projectNode = m_command.CreateNode(projectOp, unnestNode); 142Node collectNode = m_command.CreateNode(collectOp, projectNode); 167private Node VisitCollectionAggregateFunction(FunctionOp op, Node n) 170Node argNode = n.Child0; 182Node unnestNode = BuildUnnest(argNode); 188Node unnestVarRefNode = m_command.CreateNode(unnestVarRefOp); 193Node aggExprNode = m_command.CreateNode(aggregateOp, unnestVarRefNode); 196Node keyVarDefListNode = m_command.CreateNode(m_command.CreateVarDefListOp()); 200Node aggVarDefListNode = m_command.CreateVarDefListNode(aggExprNode, out aggVar); 203Node gbySubqueryNode = m_command.CreateNode(gbyOp, unnestNode, keyVarDefListNode, aggVarDefListNode); 206Node ret = AddSubqueryToParentRelOp(aggVar, gbySubqueryNode); 220public override Node Visit(FunctionOp op, Node n) 223Node newNode = null; 253protected override Node VisitJoinOp(JoinBaseOp op, Node n)

System\Data\Query\PlanCompiler\PlanCompilerUtil.cs (13)

36internal static bool IsRowTypeCaseOpWithNullability(CaseOp op, Node n, out bool thenClauseIsNull) 79internal static bool IsCollectionAggregateFunction(FunctionOp op, Node n) 113internal static Node CombinePredicates(Node predicate1, Node predicate2, Command command) 115IEnumerable<Node> andParts1 = BreakIntoAndParts(predicate1); 116IEnumerable<Node> andParts2 = BreakIntoAndParts(predicate2); 118Node result = predicate1; 120foreach (Node predicatePart2 in andParts2) 123foreach (Node predicatePart1 in andParts1) 149private static IEnumerable<Node> BreakIntoAndParts(Node predicate) 151return Helpers.GetLeafNodes<Node>(predicate,

System\Data\Query\PlanCompiler\Predicate.cs (18)

58private List<Node> m_parts; 69m_parts = new List<Node>(); 77internal Predicate(Command command, Node andTree) 92internal void AddPart(Node n) 108internal Node BuildAndTree() 110Node andNode = null; 111foreach (Node n in m_parts) 163foreach (Node part in m_parts) 186foreach (Node part in m_parts) 216foreach (Node part in m_parts) 259foreach (Node part in m_parts) 274private void InitFromAndTree(Node andTree) 301foreach (Node part in m_parts) 340private static bool IsEquiJoinPredicate(Node simplePredicateNode, out Var leftVar, out Var rightVar) 377private static bool IsEquiJoinPredicate(Node simplePredicateNode, 421private static bool PreservesNulls(Node simplePredNode, VarVec tableColumns) 475private bool IsKeyPredicate(Node left, Node right, VarVec keyVars, VarVec definitions, out Var keyVar)

System\Data\Query\PlanCompiler\PreProcessor.cs (199)

System\Data\Query\PlanCompiler\ProjectionPruner.cs (51)

System\Data\Query\PlanCompiler\PropertyPushdownHelper.cs (37)

System\Data\Query\PlanCompiler\ProviderCommandInfoUtils.cs (2)

54Node node, 86Node node)

System\Data\Query\PlanCompiler\SubqueryTrackingVisitor.cs (34)

42protected readonly Stack<Node> m_ancestors = new Stack<Node>(); 43private readonly Dictionary<Node, List<Node>> m_nodeSubqueries = new Dictionary<Node, List<Node>>(); 59protected void AddSubqueryToRelOpNode(Node relOpNode, Node subquery) 61List<Node> nestedSubqueries; 66nestedSubqueries = new List<Node>(); 79protected Node AddSubqueryToParentRelOp(Var outputVar, Node subquery) 81Node ancestor = FindRelOpAncestor(); 94protected Node FindRelOpAncestor() 96foreach (Node n in m_ancestors) 119protected override void VisitChildren(Node n) 148private Node AugmentWithSubqueries(Node input, List<Node> subqueries, bool inputFirst) 150Node newNode; 196protected override Node VisitRelOpDefault(RelOp op, Node n) 202List<Node> nestedSubqueries; 211Node newInputNode = AugmentWithSubqueries(n.Child0, nestedSubqueries, true); 225protected bool ProcessJoinOp(JoinBaseOp op, Node n) 234List<Node> nestedSubqueries; 244Node joinCondition = n.Child2; 246Node inputNode = m_command.CreateNode(m_command.CreateSingleRowTableOp()); 248Node filterNode = m_command.CreateNode(m_command.CreateFilterOp(), inputNode, joinCondition); 249Node existsNode = m_command.CreateNode(m_command.CreateExistsOp(), filterNode); 264public override Node Visit(UnnestOp op, Node n) 268List<Node> nestedSubqueries; 273Node newNode = AugmentWithSubqueries(n, nestedSubqueries, false /* inputFirst */);

System\Data\Query\PlanCompiler\TransformationRules.cs (310)

System\Data\Query\PlanCompiler\VarRefManager.cs (12)

28private Dictionary<Node, Node> m_nodeToParentMap; //child-parent mapping 29private Dictionary<Node, int> m_nodeToSiblingNumber; //the index of the given node among its siblings, i.e. 0 for a first child 40m_nodeToParentMap = new Dictionary<Node, Node>(); 41m_nodeToSiblingNumber = new Dictionary<Node, int>(); 52internal void AddChildren(Node parent) 71internal bool HasKeyReferences(VarVec keys, Node definingNode, Node targetJoinNode) 73Node currentChild = definingNode; 74Node parent; 117private static bool HasVarReferencesShallow(Node node, VarVec vars, int childIndex, out bool continueUp)

System\Data\Query\PlanCompiler\VarRemapper.cs (14)