Example #1
0
 protected override void VisitGroupByOp(GroupByBaseOp op, System.Data.Entity.Core.Query.InternalTrees.Node n)
 {
     foreach (Var key in op.Keys)
     {
         if (TypeUtils.IsStructuredType(key.Type))
         {
             this.AddPropertyRefs(key, PropertyRefList.All);
         }
     }
     this.VisitChildrenReverse(n);
 }
        /// <summary>
        /// GroupByOp handling
        /// </summary>
        /// <param name="op"></param>
        /// <param name="n"></param>
        protected override void VisitGroupByOp(GroupByBaseOp op, Node n)
        {
            // First "request" all properties for every key (that is a structured type)
            foreach (Var v in op.Keys)
            {
                if (TypeUtils.IsStructuredType(v.Type))
                {
                    AddPropertyRefs(v, PropertyRefList.All);
                }
            }

            // Now visit the aggregate definitions, the key definitions, and
            // the relop input in that order
            VisitChildrenReverse(n);
        }
        /// <summary>
        ///     GroupByBase
        ///     First, we visit the vardeflist for aggregates and potentially group aggregates
        ///     as they may reference keys (including constant keys).
        ///     Then we remove all null and constant keys that are not referenced as long as
        ///     there is one key left. We add all remaining key columns to the referenced list.
        ///     Then we walk through the vardeflist for the keys; and finally process the relop input
        ///     Once we're done, we update the "Outputs" varset - to account for any
        ///     pruned vars. The "Keys" varset will not change
        /// </summary>
        /// <param name="op"> the groupbyOp </param>
        /// <param name="n"> current subtree </param>
        /// <returns> modified subtree </returns>
        protected override Node VisitGroupByOp(GroupByBaseOp op, Node n)
        {
            // DevDiv#322980: Visit the vardeflist for aggregates and potentially group aggregates before removing
            // redundant constant keys. This is because they may depend on (reference) the keys
            for (var i = n.Children.Count - 1; i >= 2; i--)
            {
                n.Children[i] = VisitNode(n.Children[i]);
            }

            //All constant and null keys that are not referenced can be removed
            //as long as there is at least one key left.
            if (op.Keys.Count > 1)
            {
                RemoveRedundantConstantKeys(op.Keys, op.Outputs, n.Child1);
            }

            AddReference(op.Keys); // all keys are referenced

            //Visit the keys
            n.Children[1] = VisitNode(n.Children[1]);

            //Visit the input
            n.Children[0] = VisitNode(n.Children[0]);

            PruneVarSet(op.Outputs); // remove unnecessary vars from the outputs

            //SQLBUDT #543064: If there are no keys to start with
            // and none of the aggregates is referenced, the GroupBy
            // is equivalent to a SingleRowTableOp
            if (op.Keys.Count == 0 &&
                op.Outputs.Count == 0)
            {
                return(m_command.CreateNode(m_command.CreateSingleRowTableOp()));
            }

            m_command.RecomputeNodeInfo(n);
            return(n);
        }
Example #4
0
 protected override System.Data.Entity.Core.Query.InternalTrees.Node VisitGroupByOp(
     GroupByBaseOp op,
     System.Data.Entity.Core.Query.InternalTrees.Node n)
 {
     for (int index = n.Children.Count - 1; index >= 2; --index)
     {
         n.Children[index] = this.VisitNode(n.Children[index]);
     }
     if (op.Keys.Count > 1)
     {
         this.RemoveRedundantConstantKeys(op.Keys, op.Outputs, n.Child1);
     }
     this.AddReference((IEnumerable <Var>)op.Keys);
     n.Children[1] = this.VisitNode(n.Children[1]);
     n.Children[0] = this.VisitNode(n.Children[0]);
     this.PruneVarSet(op.Outputs);
     if (op.Keys.Count == 0 && op.Outputs.Count == 0)
     {
         return(this.m_command.CreateNode((Op)this.m_command.CreateSingleRowTableOp()));
     }
     this.m_command.RecomputeNodeInfo(n);
     return(n);
 }
        protected override void VisitGroupByOp(GroupByBaseOp op, Node n)
        {
            VisitRelOpDefault(op, n);
            AssertRelOpOrPhysicalOp(n.Child0.Op);

            for (var i = 1; i < n.Children.Count; i++)
            {
                AssertOpType(n.Children[i].Op, OpType.VarDefList);
            }
        }
 /// <summary>
 ///     Default handler for all GroupBy ops
 /// </summary>
 /// <param name="op"> sort op </param>
 /// <param name="n"> </param>
 protected virtual void VisitGroupByOp(GroupByBaseOp op, Node n)
 {
     VisitRelOpDefault(op, n);
 }
        /// <summary>
        ///     GroupByOp handling
        /// </summary>
        /// <param name="op"> </param>
        /// <param name="n"> </param>
        protected override void VisitGroupByOp(GroupByBaseOp op, Node n)
        {
            // First "request" all properties for every key (that is a structured type)
            foreach (var v in op.Keys)
            {
                if (TypeUtils.IsStructuredType(v.Type))
                {
                    AddPropertyRefs(v, PropertyRefList.All);
                }
            }

            // Now visit the aggregate definitions, the key definitions, and 
            // the relop input in that order
            VisitChildrenReverse(n);
        }
Example #8
0
 protected override void VisitGroupByOp(GroupByBaseOp op, Node n)
 {
     VisitRelOpDefault(op, n);
     Map(op.Outputs);
     Map(op.Keys);
 }
Example #9
0
 protected override void VisitGroupByOp(GroupByBaseOp op, Node n)
 {
     VisitRelOpDefault(op, n);
     Map(op.Outputs);
     Map(op.Keys);
 }
Example #10
0
 protected override void VisitGroupByOp(GroupByBaseOp op, System.Data.Entity.Core.Query.InternalTrees.Node n)
 {
     this.VisitRelOpDefault((RelOp)op, n);
     this.Map(op.Outputs);
     this.Map(op.Keys);
 }