protected override void VisitSortOp(SortBaseOp op, Node n) { using (new Dump.AutoXml(this, "keys")) { foreach (SortKey key in op.Keys) { using (new Dump.AutoXml(this, "sortKey", new Dictionary <string, object>() { { "Var", (object)key.Var }, { "Ascending", (object)key.AscendingSort }, { "Collation", (object)key.Collation } })) ; } } this.VisitChildren(n); }
protected override void VisitSortOp(SortBaseOp op, Node n) { using (new AutoXml(this, "keys")) { foreach (var sortKey in op.Keys) { var attrs = new Dictionary <string, object>(); attrs.Add("Var", sortKey.Var); attrs.Add("Ascending", sortKey.AscendingSort); attrs.Add("Collation", sortKey.Collation); using (new AutoXml(this, "sortKey", attrs)) { } } } VisitChildren(n); }
/// <summary> /// Computes a NodeInfo for a ConstrainedSortOp/SortOp. /// Definitions = Definitions of the input Relop /// LocalDefinitions = not allowed /// Keys = Keys of the input Relop /// External References = any external references from the input + any external /// references from the keys /// RowCount = Input's RowCount /// NonNullabeDefinitions = NonNullabeDefinitions of the input RelOp /// NonNullableInputDefinitions = NonNullabeDefinitions of the input RelOp /// </summary> /// <param name="op"> The SortOp </param> /// <param name="n"> corresponding Node </param> protected override NodeInfo VisitSortOp(SortBaseOp op, Node n) { var nodeInfo = InitExtendedNodeInfo(n); var relOpChildNodeInfo = GetExtendedNodeInfo(n.Child0); // definitions are my child's definitions nodeInfo.Definitions.Or(relOpChildNodeInfo.Definitions); // My references are my child's external references + those made // by my sort keys nodeInfo.ExternalReferences.Or(relOpChildNodeInfo.ExternalReferences); nodeInfo.ExternalReferences.Minus(relOpChildNodeInfo.Definitions); // my keys are my child's keys nodeInfo.Keys.InitFrom(relOpChildNodeInfo.Keys); //Non-nullable definitions are same as the input nodeInfo.NonNullableDefinitions.InitFrom(relOpChildNodeInfo.NonNullableDefinitions); nodeInfo.NonNullableVisibleDefinitions.InitFrom(relOpChildNodeInfo.NonNullableDefinitions); //Row counts are same as the input nodeInfo.InitRowCountFrom(relOpChildNodeInfo); // For constrained sort, if the Limit value is Constant(1) and WithTies is false, // then MinRows and MaxRows can be adjusted to 0, 1. if (OpType.ConstrainedSort == op.OpType && OpType.Constant == n.Child2.Op.OpType && !((ConstrainedSortOp)op).WithTies) { var constOp = (ConstantBaseOp)n.Child2.Op; if (TypeHelpers.IsIntegerConstant(constOp.Type, constOp.Value, 1)) { nodeInfo.SetRowCount(RowCount.Zero, RowCount.One); } } return(nodeInfo); }
protected override NodeInfo VisitSortOp(SortBaseOp op, Node n) { ExtendedNodeInfo extendedNodeInfo1 = this.InitExtendedNodeInfo(n); ExtendedNodeInfo extendedNodeInfo2 = this.GetExtendedNodeInfo(n.Child0); extendedNodeInfo1.Definitions.Or(extendedNodeInfo2.Definitions); extendedNodeInfo1.ExternalReferences.Or(extendedNodeInfo2.ExternalReferences); extendedNodeInfo1.ExternalReferences.Minus(extendedNodeInfo2.Definitions); extendedNodeInfo1.Keys.InitFrom(extendedNodeInfo2.Keys); extendedNodeInfo1.NonNullableDefinitions.InitFrom(extendedNodeInfo2.NonNullableDefinitions); extendedNodeInfo1.NonNullableVisibleDefinitions.InitFrom(extendedNodeInfo2.NonNullableDefinitions); extendedNodeInfo1.InitRowCountFrom(extendedNodeInfo2); if (OpType.ConstrainedSort == op.OpType && n.Child2.Op.OpType == OpType.Constant && !((ConstrainedSortOp)op).WithTies) { ConstantBaseOp op1 = (ConstantBaseOp)n.Child2.Op; if (TypeHelpers.IsIntegerConstant(op1.Type, op1.Value, 1L)) { extendedNodeInfo1.SetRowCount(RowCount.Zero, RowCount.One); } } return((NodeInfo)extendedNodeInfo1); }
/// <summary> /// Default handler for all SortOps /// </summary> /// <param name="op"> sort op </param> /// <param name="n"> </param> protected virtual void VisitSortOp(SortBaseOp op, Node n) { VisitRelOpDefault(op, n); }
protected override void VisitSortOp(SortBaseOp op, Node n) { VisitRelOpDefault(op, n); AssertRelOpOrPhysicalOp(n.Child0.Op); }
/// <summary> /// SortOp handling /// /// First, "request" that for any sort key that is a structured type, we /// need all its properties. Then process any local definitions, and /// finally the relop input /// </summary> /// <param name="op"> </param> /// <param name="n"> </param> protected override void VisitSortOp(SortBaseOp op, Node n) { // foreach sort key, every single bit of the Var is needed foreach (var sk in op.Keys) { if (TypeUtils.IsStructuredType(sk.Var.Type)) { AddPropertyRefs(sk.Var, PropertyRefList.All); } } // if the sort has any local definitions, process those first if (n.HasChild1) { VisitNode(n.Child1); } // then process the relop input VisitNode(n.Child0); }
protected override void VisitSortOp(SortBaseOp op, Node n) { VisitRelOpDefault(op, n); Map(op.Keys); }
protected virtual void VisitSortOp(SortBaseOp op, Node n) { this.VisitRelOpDefault((RelOp)op, n); }
protected virtual void VisitSortOp(SortBaseOp op, Node n) { VisitRelOpDefault(op, n); }
// <summary> // A default processor for all SortOps. // Allows new visitors to just override this to handle ConstrainedSortOp/SortOp. // </summary> // <param name="op"> the SetOp </param> // <param name="n"> the node to process </param> // <returns> a potentially modified subtree </returns> protected virtual TResultType VisitSortOp(SortBaseOp op, Node n) { return(VisitRelOpDefault(op, n)); }