internal override Expression Visit(Expression expr)
{
if (expr == null)
{
return(expr);
}
if (HpcLinqExpression.IsConstant(expr))
{
object val = ExpressionSimplifier.Evaluate(expr);
if (val is IQueryable)
{
QueryNodeInfo nodeInfo;
if (this.m_referencedQueryMap.TryGetValue(((IQueryable)val).Expression, out nodeInfo))
{
string name = "side__" + this.m_idx;
this.m_idx++;
this.m_referencedQueries.Add(new Pair <string, DryadQueryNode>(name, nodeInfo.queryNode));
return(Expression.Parameter(expr.Type, name));
}
throw new DryadLinqException(HpcLinqErrorCode.UnhandledQuery,
String.Format(SR.UnhandledQuery, HpcLinqExpression.Summarize(expr)));
}
return(expr);
}
return(base.Visit(expr));
}
internal override Expression Visit(Expression expr)
{
if (expr == null)
{
return(expr);
}
if (HpcLinqExpression.IsConstant(expr))
{
object val = ExpressionSimplifier.Evaluate(expr);
if (val is IQueryable)
{
this.m_querySet.Add(((IQueryable)val).Expression);
}
return(expr);
}
return(base.Visit(expr));
}
private static bool GetDecompositionInfoList(ParameterExpression keyParam,
ParameterExpression groupParam,
Expression expr,
List <DecompositionInfo> infoList,
HpcLinqCodeGen codeGen)
{
IEnumerable <Expression> argList = null;
if (HpcLinqExpression.IsConstant(expr))
{
return(true);
}
else if (expr is BinaryExpression)
{
BinaryExpression be = (BinaryExpression)expr;
argList = new Expression[] { be.Left, be.Right };
}
else if (expr is UnaryExpression)
{
UnaryExpression ue = (UnaryExpression)expr;
return(GetDecompositionInfoList(keyParam, groupParam, ue.Operand, infoList, codeGen));
}
else if (expr is ConditionalExpression)
{
ConditionalExpression ce = (ConditionalExpression)expr;
argList = new Expression[] { ce.Test, ce.IfTrue, ce.IfFalse };
}
else if (expr is MethodCallExpression)
{
MethodCallExpression mcExpr = (MethodCallExpression)expr;
DecompositionInfo dinfo = GetDecompositionInfo(groupParam, mcExpr, codeGen);
if (dinfo != null)
{
infoList.Add(dinfo);
return(true);
}
if (mcExpr.Object != null)
{
bool isDecomposed = GetDecompositionInfoList(keyParam, groupParam,
mcExpr.Object,
infoList, codeGen);
if (!isDecomposed)
{
return(false);
}
}
argList = mcExpr.Arguments;
}
else if (expr is NewExpression)
{
argList = ((NewExpression)expr).Arguments;
}
else if (expr is NewArrayExpression)
{
argList = ((NewArrayExpression)expr).Expressions;
}
else if (expr is ListInitExpression)
{
ListInitExpression li = (ListInitExpression)expr;
bool isDecomposed = GetDecompositionInfoList(keyParam, groupParam,
li.NewExpression,
infoList, codeGen);
for (int i = 0, n = li.Initializers.Count; i < n; i++)
{
ElementInit ei = li.Initializers[i];
foreach (Expression arg in ei.Arguments)
{
isDecomposed = GetDecompositionInfoList(keyParam, groupParam, arg, infoList, codeGen);
if (!isDecomposed)
{
return(false);
}
}
}
return(true);
}
else if (expr is MemberInitExpression)
{
MemberInitExpression mi = (MemberInitExpression)expr;
bool isDecomposed = GetDecompositionInfoList(keyParam, groupParam,
mi.NewExpression,
infoList, codeGen);
if (!isDecomposed)
{
return(false);
}
foreach (MemberBinding mb in mi.Bindings)
{
isDecomposed = GetDecompositionInfoList(keyParam, groupParam, mb, infoList, codeGen);
if (!isDecomposed)
{
return(false);
}
}
return(true);
}
else if (keyParam == null)
{
while (expr is MemberExpression)
{
MemberExpression me = (MemberExpression)expr;
if (me.Expression == groupParam &&
me.Member.Name == "Key")
{
return(true);
}
expr = me.Expression;
}
return(false);
}
else
{
while (expr is MemberExpression)
{
expr = ((MemberExpression)expr).Expression;
}
return(expr == keyParam);
}
foreach (var argExpr in argList)
{
bool isDecomposed = GetDecompositionInfoList(keyParam, groupParam, argExpr, infoList, codeGen);
if (!isDecomposed)
{
return(false);
}
}
return(true);
}
