/// <summary>
/// If the op is a collection aggregate function it checks whether its arguement can be translated over
/// a single group aggregate var. If so, it is tracked as a candidate to be pushed into that
/// group by into node.
/// </summary>
/// <param name="op"></param>
/// <param name="n"></param>
public override void Visit(FunctionOp op, Node n)
{
VisitDefault(n);
if (!PlanCompilerUtil.IsCollectionAggregateFunction(op, n))
{
return;
}
PlanCompiler.Assert(n.Children.Count == 1, "Aggregate Function must have one argument");
Node argumentNode = n.Child0;
GroupAggregateVarInfo referencedGroupAggregateVarInfo;
Node templateNode;
bool isUnnested;
if (GroupAggregateVarComputationTranslator.TryTranslateOverGroupAggregateVar(n.Child0, false, _command, _groupAggregateVarInfoManager, out referencedGroupAggregateVarInfo, out templateNode, out isUnnested) &&
(isUnnested || AggregatePushdownUtil.IsVarRefOverGivenVar(templateNode, referencedGroupAggregateVarInfo.GroupAggregateVar)))
{
referencedGroupAggregateVarInfo.CandidateAggregateNodes.Add(new KeyValuePair <Node, Node>(n, templateNode));
}
}
/// <summary>
/// Try to produce an equivalent tree to the input subtree, over a single group aggregate variable.
/// Such translation can only be produced if all external references of the input subtree are to a
/// single group aggregate var, or to vars that are can be translated over that single group
/// aggregate var
/// </summary>
/// <param name="subtree">The input subtree</param>
/// <param name="isVarDefinition"></param>
/// <param name="command"></param>
/// <param name="groupAggregateVarInfoManager"></param>
/// <param name="groupAggregateVarInfo">The groupAggregateVarInfo over which the input subtree can be translated </param>
/// <param name="templateNode">A tree that is equvalent to the input tree, but over the group aggregate variable
/// represented by the groupAggregetVarInfo</param>
/// <param name="isUnnested"></param>
/// <returns>True, if the translation can be done, false otherwise</returns>
public static bool TryTranslateOverGroupAggregateVar(
Node subtree,
bool isVarDefinition,
Command command,
GroupAggregateVarInfoManager groupAggregateVarInfoManager,
out GroupAggregateVarInfo groupAggregateVarInfo,
out Node templateNode,
out bool isUnnested)
{
GroupAggregateVarComputationTranslator handler = new GroupAggregateVarComputationTranslator(command, groupAggregateVarInfoManager);
Node inputNode = subtree;
SoftCastOp softCastOp = null;
bool isCollect;
if (inputNode.Op.OpType == OpType.SoftCast)
{
softCastOp = (SoftCastOp)inputNode.Op;
inputNode = inputNode.Child0;
}
if (inputNode.Op.OpType == OpType.Collect)
{
templateNode = handler.VisitCollect(inputNode);
isCollect = true;
}
else
{
templateNode = handler.VisitNode(inputNode);
isCollect = false;
}
groupAggregateVarInfo = handler._targetGroupAggregateVarInfo;
isUnnested = handler._isUnnested;
if (handler._targetGroupAggregateVarInfo == null || templateNode == null)
{
return(false);
}
if (softCastOp != null)
{
SoftCastOp newSoftCastOp;
//
// The type needs to be fixed only if the unnesting happened during this translation.
// That can be recognized by these two cases:
// 1) if the input node was a collect, or
// 2) if the input did not represent a var definition, but a function aggregate argument and
// the template is VarRef of a group aggregate var.
//
if (isCollect || !isVarDefinition && AggregatePushdownUtil.IsVarRefOverGivenVar(templateNode, handler._targetGroupAggregateVarInfo.GroupAggregateVar))
{
newSoftCastOp = command.CreateSoftCastOp(TypeHelpers.GetEdmType <CollectionType>(softCastOp.Type).TypeUsage);
}
else
{
newSoftCastOp = softCastOp;
}
templateNode = command.CreateNode(newSoftCastOp, templateNode);
}
return(true);
}