private Node VisitCollectionAggregateFunction(FunctionOp op, Node n) { TypeUsage type = (TypeUsage)null; Node child0 = n.Child0; if (OpType.SoftCast == child0.Op.OpType) { type = TypeHelpers.GetEdmType <CollectionType>(child0.Op.Type).TypeUsage; child0 = child0.Child0; while (OpType.SoftCast == child0.Op.OpType) { child0 = child0.Child0; } } Node node1 = this.BuildUnnest(child0); Var column = (node1.Op as UnnestOp).Table.Columns[0]; AggregateOp aggregateOp = this.m_command.CreateAggregateOp(op.Function, false); Node node2 = this.m_command.CreateNode((Op)this.m_command.CreateVarRefOp(column)); if (type != null) { node2 = this.m_command.CreateNode((Op)this.m_command.CreateSoftCastOp(type), node2); } Node node3 = this.m_command.CreateNode((Op)aggregateOp, node2); VarVec varVec1 = this.m_command.CreateVarVec(); Node node4 = this.m_command.CreateNode((Op)this.m_command.CreateVarDefListOp()); VarVec varVec2 = this.m_command.CreateVarVec(); Var computedVar; Node varDefListNode = this.m_command.CreateVarDefListNode(node3, out computedVar); varVec2.Set(computedVar); Node node5 = this.m_command.CreateNode((Op)this.m_command.CreateGroupByOp(varVec1, varVec2), node1, node4, varDefListNode); return(this.AddSubqueryToParentRelOp(computedVar, node5)); }
/// <summary> /// Returns the ReplicateGroupOp based on the current value of Settings.Default.GroupByReplicateAnnotation, /// and the specified AggregateOp. Note that if the ReplicateGroupOp is not grouping on an annotation, /// the AggregateOp will be override with the value MEAN. /// </summary> public static ReplicateGroupOp FromCurrentSettings(SrmSettings settings, AggregateOp aggregateOp) { AnnotationDef groupByAnnotationDef = null; string annotationName = Settings.Default.GroupByReplicateAnnotation; if (null != annotationName) { groupByAnnotationDef = settings.DataSettings.AnnotationDefs.FirstOrDefault( annotationDef => annotationName == annotationDef.Name); } if (null == groupByAnnotationDef) { aggregateOp = AggregateOp.MEAN; } return(new ReplicateGroupOp(groupByAnnotationDef, aggregateOp)); }
/// <summary> /// Converts a collection aggregate function count(X), where X is a collection into /// two parts. Part A is a groupby subquery that looks like /// GroupBy(Unnest(X), empty, count(y)) /// where "empty" describes the fact that the groupby has no keys, and y is an /// element var of the Unnest /// /// Part 2 is a VarRef that refers to the aggregate var for count(y) described above. /// /// Logically, we would replace the entire functionOp by element(GroupBy...). However, /// since we also want to translate element() into single-row-subqueries, we do this /// here as well. /// /// The function itself is replaced by the VarRef, and the GroupBy is added to the list /// of scalar subqueries for the current relOp node on the stack /// /// </summary> /// <param name="op">the functionOp for the collection agg</param> /// <param name="n">current subtree</param> /// <returns>the VarRef node that should replace the function</returns> private Node VisitCollectionAggregateFunction(FunctionOp op, Node n) { TypeUsage softCastType = null; Node argNode = n.Child0; if (OpType.SoftCast == argNode.Op.OpType) { softCastType = TypeHelpers.GetEdmType <CollectionType>(argNode.Op.Type).TypeUsage; argNode = argNode.Child0; while (OpType.SoftCast == argNode.Op.OpType) { argNode = argNode.Child0; } } Node unnestNode = BuildUnnest(argNode); UnnestOp unnestOp = unnestNode.Op as UnnestOp; Var unnestOutputVar = unnestOp.Table.Columns[0]; AggregateOp aggregateOp = m_command.CreateAggregateOp(op.Function, false); VarRefOp unnestVarRefOp = m_command.CreateVarRefOp(unnestOutputVar); Node unnestVarRefNode = m_command.CreateNode(unnestVarRefOp); if (softCastType != null) { unnestVarRefNode = m_command.CreateNode(m_command.CreateSoftCastOp(softCastType), unnestVarRefNode); } Node aggExprNode = m_command.CreateNode(aggregateOp, unnestVarRefNode); VarVec keyVars = m_command.CreateVarVec(); // empty keys Node keyVarDefListNode = m_command.CreateNode(m_command.CreateVarDefListOp()); VarVec gbyOutputVars = m_command.CreateVarVec(); Var aggVar; Node aggVarDefListNode = m_command.CreateVarDefListNode(aggExprNode, out aggVar); gbyOutputVars.Set(aggVar); GroupByOp gbyOp = m_command.CreateGroupByOp(keyVars, gbyOutputVars); Node gbySubqueryNode = m_command.CreateNode(gbyOp, unnestNode, keyVarDefListNode, aggVarDefListNode); // "Move" this subquery to my parent relop Node ret = AddSubqueryToParentRelOp(aggVar, gbySubqueryNode); return(ret); }
public RetentionTimeTransform(RTPeptideValue rtPeptideValue, IRetentionTimeTransformOp rtAlignment, AggregateOp aggregateOp) { RtPeptideValue = rtPeptideValue; RtTransformOp = rtAlignment; AggregateOp = aggregateOp; }
/// <summary> /// Returns the ReplicateGroupOp based on the current value of Settings.Default.GroupByReplicateAnnotation, /// and the current Settings.Default.ShowPeptideCV. Note that if the ReplicateGroupOp is not grouping on /// an annotation, the AggregateOp will always be set to MEAN. /// </summary> public static ReplicateGroupOp FromCurrentSettings(SrmSettings settings) { return(FromCurrentSettings(settings, AggregateOp.FromCurrentSettings())); }
private ReplicateGroupOp(AnnotationDef groupByAnnotationDef, AggregateOp aggregateOp) { GroupByAnnotation = groupByAnnotationDef; AggregateOp = aggregateOp; }
public override void Visit(AggregateOp op, Node n) { VisitScalarOpDefault(op, n); }
/// <summary> /// Clone an aggregateop /// </summary> /// <param name="op">The Op to Copy</param> /// <param name="n">The Node that references the Op</param> /// <returns>A copy of the original Node that references a copy of the original Op</returns> public override Node Visit(AggregateOp op, Node n) { return(CopyDefault(m_destCmd.CreateAggregateOp(op.AggFunc, op.IsDistinctAggregate), n)); }
/// <summary> /// Visitor pattern method for AggregateOp /// </summary> /// <param name="op"> The AggregateOp being visited </param> /// <param name="n"> The Node that references the Op </param> public virtual void Visit(AggregateOp op, Node n) { VisitScalarOpDefault(op, n); }
public override Node Visit(AggregateOp op, Node n) { return(null); }
public override Node Visit(AggregateOp op, Node n) { return null; }
public override System.Data.Entity.Core.Query.InternalTrees.Node Visit( AggregateOp op, System.Data.Entity.Core.Query.InternalTrees.Node n) { return((System.Data.Entity.Core.Query.InternalTrees.Node)null); }
// <summary> // Clone an aggregateop // </summary> // <param name="op"> The Op to Copy </param> // <param name="n"> The Node that references the Op </param> // <returns> A copy of the original Node that references a copy of the original Op </returns> public override Node Visit(AggregateOp op, Node n) { return CopyDefault(m_destCmd.CreateAggregateOp(op.AggFunc, op.IsDistinctAggregate), n); }
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer) { if (untypedValue == null) { serializer.Serialize(writer, null); return; } AggregateOp value = (AggregateOp)untypedValue; switch (value) { case AggregateOp.Argmax: serializer.Serialize(writer, "argmax"); return; case AggregateOp.Argmin: serializer.Serialize(writer, "argmin"); return; case AggregateOp.Average: serializer.Serialize(writer, "average"); return; case AggregateOp.Ci0: serializer.Serialize(writer, "ci0"); return; case AggregateOp.Ci1: serializer.Serialize(writer, "ci1"); return; case AggregateOp.Count: serializer.Serialize(writer, "count"); return; case AggregateOp.Distinct: serializer.Serialize(writer, "distinct"); return; case AggregateOp.Max: serializer.Serialize(writer, "max"); return; case AggregateOp.Mean: serializer.Serialize(writer, "mean"); return; case AggregateOp.Median: serializer.Serialize(writer, "median"); return; case AggregateOp.Min: serializer.Serialize(writer, "min"); return; case AggregateOp.Missing: serializer.Serialize(writer, "missing"); return; case AggregateOp.Q1: serializer.Serialize(writer, "q1"); return; case AggregateOp.Q3: serializer.Serialize(writer, "q3"); return; case AggregateOp.Stderr: serializer.Serialize(writer, "stderr"); return; case AggregateOp.Stdev: serializer.Serialize(writer, "stdev"); return; case AggregateOp.Stdevp: serializer.Serialize(writer, "stdevp"); return; case AggregateOp.Sum: serializer.Serialize(writer, "sum"); return; case AggregateOp.Valid: serializer.Serialize(writer, "valid"); return; case AggregateOp.Values: serializer.Serialize(writer, "values"); return; case AggregateOp.Variance: serializer.Serialize(writer, "variance"); return; case AggregateOp.Variancep: serializer.Serialize(writer, "variancep"); return; } throw new Exception("Cannot marshal type AggregateOp"); }