public Exp validate(Exp exp, boolean scalar) {
Exp resolved;
try {
resolved = (Exp) resolvedNodes.get(exp);
} catch (ClassCastException e) {
// A classcast exception will occur if there is a String
// placeholder in the map. This is an internal error -- should
// not occur for any query, valid or invalid.
throw Util.newInternal(
e, "Infinite recursion encountered while validating '" + Util.unparse(exp) + "'");
}
if (resolved == null) {
try {
stack.push((QueryPart) exp);
// To prevent recursion, put in a placeholder while we're
// resolving.
resolvedNodes.put((QueryPart) exp, placeHolder);
resolved = exp.accept(this);
Util.assertTrue(resolved != null);
resolvedNodes.put((QueryPart) exp, (QueryPart) resolved);
} finally {
stack.pop();
}
}
if (scalar) {
final Type type = resolved.getType();
if (!TypeUtil.canEvaluate(type)) {
String exprString = Util.unparse(resolved);
throw MondrianResource.instance().MdxMemberExpIsSet.ex(exprString);
}
}
return resolved;
}
public void validate(Formula formula) {
final Formula resolved = (Formula) resolvedNodes.get(formula);
if (resolved != null) {
return; // already resolved
}
try {
stack.push(formula);
resolvedNodes.put(formula, placeHolder);
formula.accept(this);
resolvedNodes.put(formula, formula);
} finally {
stack.pop();
}
}
public void validate(QueryAxis axis) {
final QueryAxis resolved = (QueryAxis) resolvedNodes.get(axis);
if (resolved != null) {
return; // already resolved
}
try {
stack.push(axis);
resolvedNodes.put(axis, placeHolder);
axis.resolve(this);
resolvedNodes.put(axis, axis);
} finally {
stack.pop();
}
}
public void validate(MemberProperty memberProperty) {
MemberProperty resolved = (MemberProperty) resolvedNodes.get(memberProperty);
if (resolved != null) {
return; // already resolved
}
try {
stack.push(memberProperty);
resolvedNodes.put(memberProperty, placeHolder);
memberProperty.resolve(this);
resolvedNodes.put(memberProperty, memberProperty);
} finally {
stack.pop();
}
}
public void validate(ParameterExpr parameterExpr) {
ParameterExpr resolved = (ParameterExpr) resolvedNodes.get(parameterExpr);
if (resolved != null) {
return; // already resolved
}
try {
stack.push(parameterExpr);
resolvedNodes.put(parameterExpr, placeHolder);
resolved = (ParameterExpr) parameterExpr.accept(this);
assert resolved != null;
resolvedNodes.put(parameterExpr, resolved);
} finally {
stack.pop();
}
}
private boolean requiresExpression(int n) {
if (n < 1) {
return false;
}
final Object parent = stack.get(n - 1);
if (parent instanceof Formula) {
return ((Formula) parent).isMember();
} else if (parent instanceof ResolvedFunCall) {
final ResolvedFunCall funCall = (ResolvedFunCall) parent;
if (funCall.getFunDef().getSyntax() == Syntax.Parentheses) {
return requiresExpression(n - 1);
} else {
int k = whichArg(funCall, (Exp) stack.get(n));
if (k < 0) {
// Arguments of call have mutated since call was placed
// on stack. Presumably the call has already been
// resolved correctly, so the answer we give here is
// irrelevant.
return false;
}
final FunDef funDef = funCall.getFunDef();
final int[] parameterTypes = funDef.getParameterCategories();
return parameterTypes[k] != Category.Set;
}
} else if (parent instanceof UnresolvedFunCall) {
final UnresolvedFunCall funCall = (UnresolvedFunCall) parent;
if (funCall.getSyntax() == Syntax.Parentheses || funCall.getFunName().equals("*")) {
return requiresExpression(n - 1);
} else {
int k = whichArg(funCall, (Exp) stack.get(n));
if (k < 0) {
// Arguments of call have mutated since call was placed
// on stack. Presumably the call has already been
// resolved correctly, so the answer we give here is
// irrelevant.
return false;
}
return requiresExpression(funCall, k);
}
} else {
return false;
}
}
public boolean requiresExpression() {
return requiresExpression(stack.size() - 1);
}
