{
constantType = Class.forName(op.getConstantType());
}
catch (ClassNotFoundException e)
{
throw new EPException("Error looking up class name '" + op.getConstantType() + "' to resolve as constant type");
}
}
return new ExprConstantNodeImpl(op.getConstant(), constantType);
}
else if (expr instanceof ConcatExpression)
{
return new ExprConcatNode();
}
else if (expr instanceof SubqueryExpression)
{
SubqueryExpression sub = (SubqueryExpression) expr;
StatementSpecRaw rawSubselect = map(sub.getModel(), mapContext);
return new ExprSubselectRowNode(rawSubselect);
}
else if (expr instanceof SubqueryInExpression)
{
SubqueryInExpression sub = (SubqueryInExpression) expr;
StatementSpecRaw rawSubselect = map(sub.getModel(), mapContext);
ExprSubselectInNode inSub = new ExprSubselectInNode(rawSubselect);
inSub.setNotIn(sub.isNotIn());
return inSub;
}
else if (expr instanceof SubqueryExistsExpression)
{
SubqueryExistsExpression sub = (SubqueryExistsExpression) expr;
StatementSpecRaw rawSubselect = map(sub.getModel(), mapContext);
return new ExprSubselectExistsNode(rawSubselect);
}
else if (expr instanceof SubqueryQualifiedExpression)
{
SubqueryQualifiedExpression sub = (SubqueryQualifiedExpression) expr;
StatementSpecRaw rawSubselect = map(sub.getModel(), mapContext);
boolean isNot = false;
RelationalOpEnum relop = null;
if (sub.getOperator().equals("!="))
{
isNot = true;
}
if (sub.getOperator().equals("="))
{
}
else
{
relop = RelationalOpEnum.parse(sub.getOperator());
}
return new ExprSubselectAllSomeAnyNode(rawSubselect, isNot, sub.isAll(), relop);
}
else if (expr instanceof CountStarProjectionExpression)
{
return new ExprCountNode(false);
}
else if (expr instanceof CountProjectionExpression)
{
CountProjectionExpression count = (CountProjectionExpression) expr;
return new ExprCountNode(count.isDistinct());
}
else if (expr instanceof AvgProjectionExpression)
{
AvgProjectionExpression avg = (AvgProjectionExpression) expr;
return new ExprAvgNode(avg.isDistinct());
}
else if (expr instanceof SumProjectionExpression)
{
SumProjectionExpression avg = (SumProjectionExpression) expr;
return new ExprSumNode(avg.isDistinct());
}
else if (expr instanceof BetweenExpression)
{
BetweenExpression between = (BetweenExpression) expr;
return new ExprBetweenNodeImpl(between.isLowEndpointIncluded(), between.isHighEndpointIncluded(), between.isNotBetween());
}
else if (expr instanceof PriorExpression)
{
return new ExprPriorNode();
}
else if (expr instanceof PreviousExpression)
{
PreviousExpression prev = (PreviousExpression) expr;
return new ExprPreviousNode(PreviousType.valueOf(prev.getType().toString()));
}
else if (expr instanceof StaticMethodExpression)
{
StaticMethodExpression method = (StaticMethodExpression) expr;
List<ExprChainedSpec> chained = mapChains(method.getChain(), mapContext);
chained.add(0, new ExprChainedSpec(method.getClassName(), Collections.<ExprNode>emptyList(), false));
return new ExprDotNode(chained,
mapContext.getConfiguration().getEngineDefaults().getExpression().isDuckTyping(),
mapContext.getConfiguration().getEngineDefaults().getExpression().isUdfCache());
}
else if (expr instanceof MinProjectionExpression)
{
MinProjectionExpression method = (MinProjectionExpression) expr;
return new ExprMinMaxAggrNode(method.isDistinct(), MinMaxTypeEnum.MIN);
}
else if (expr instanceof MaxProjectionExpression)
{
MaxProjectionExpression method = (MaxProjectionExpression) expr;
return new ExprMinMaxAggrNode(method.isDistinct(), MinMaxTypeEnum.MAX);
}
else if (expr instanceof NotExpression)
{
return new ExprNotNode();
}
else if (expr instanceof InExpression)
{
InExpression in = (InExpression) expr;
return new ExprInNodeImpl(in.isNotIn());
}
else if (expr instanceof CoalesceExpression)
{
return new ExprCoalesceNode();
}
else if (expr instanceof CaseWhenThenExpression)
{
return new ExprCaseNode(false);
}
else if (expr instanceof CaseSwitchExpression)
{
return new ExprCaseNode(true);
}
else if (expr instanceof MaxRowExpression)
{
return new ExprMinMaxRowNode(MinMaxTypeEnum.MAX);
}
else if (expr instanceof MinRowExpression)
{
return new ExprMinMaxRowNode(MinMaxTypeEnum.MIN);
}
else if (expr instanceof BitwiseOpExpression)
{
BitwiseOpExpression bit = (BitwiseOpExpression) expr;
return new ExprBitWiseNode(bit.getBinaryOp());
}
else if (expr instanceof ArrayExpression)
{
return new ExprArrayNode();
}
else if (expr instanceof LikeExpression)
{
LikeExpression like = (LikeExpression) expr;
return new ExprLikeNode(like.isNot());
}
else if (expr instanceof RegExpExpression)
{
RegExpExpression regexp = (RegExpExpression) expr;
return new ExprRegexpNode(regexp.isNot());
}
else if (expr instanceof MedianProjectionExpression)
{
MedianProjectionExpression median = (MedianProjectionExpression) expr;
return new ExprMedianNode(median.isDistinct());
}
else if (expr instanceof AvedevProjectionExpression)
{
AvedevProjectionExpression node = (AvedevProjectionExpression) expr;
return new ExprAvedevNode(node.isDistinct());
}
else if (expr instanceof StddevProjectionExpression)
{
StddevProjectionExpression node = (StddevProjectionExpression) expr;
return new ExprStddevNode(node.isDistinct());
}
else if (expr instanceof LastEverProjectionExpression)
{
LastEverProjectionExpression node = (LastEverProjectionExpression) expr;
return new ExprLastEverNode(node.isDistinct());
}
else if (expr instanceof FirstEverProjectionExpression)
{
FirstEverProjectionExpression node = (FirstEverProjectionExpression) expr;
return new ExprFirstEverNode(node.isDistinct());
}
else if (expr instanceof InstanceOfExpression)
{
InstanceOfExpression node = (InstanceOfExpression) expr;
return new ExprInstanceofNode(node.getTypeNames());
}
else if (expr instanceof TypeOfExpression)
{
return new ExprTypeofNode();
}
else if (expr instanceof CastExpression)
{
CastExpression node = (CastExpression) expr;
return new ExprCastNode(node.getTypeName());
}
else if (expr instanceof PropertyExistsExpression)
{
return new ExprPropertyExistsNode();
}
else if (expr instanceof CurrentTimestampExpression)
{
return new ExprTimestampNode();
}
else if (expr instanceof TimePeriodExpression)
{
TimePeriodExpression tpe = (TimePeriodExpression) expr;
return new ExprTimePeriodImpl(tpe.isHasYears(), tpe.isHasMonths(), tpe.isHasWeeks(), tpe.isHasDays(), tpe.isHasHours(), tpe.isHasMinutes(), tpe.isHasSeconds(), tpe.isHasMilliseconds());
}
else if (expr instanceof NewOperatorExpression) {
NewOperatorExpression noe = (NewOperatorExpression) expr;
return new ExprNewNode(noe.getColumnNames().toArray(new String[noe.getColumnNames().size()]));
}
else if (expr instanceof CompareListExpression)
{
CompareListExpression exp = (CompareListExpression) expr;
if ((exp.getOperator().equals("=")) || (exp.getOperator().equals("!=")))
{
return new ExprEqualsAllAnyNode((exp.getOperator().equals("!=")), exp.isAll());
}
else
{
return new ExprRelationalOpAllAnyNode(RelationalOpEnum.parse(exp.getOperator()), exp.isAll());
}
}
else if (expr instanceof SubstitutionParameterExpression)
{
SubstitutionParameterExpression node = (SubstitutionParameterExpression) expr;
if (!(node.isSatisfied()))
{
throw new EPException("Substitution parameter value for index " + node.getIndex() + " not set, please provide a value for this parameter");
}
return new ExprConstantNodeImpl(node.getConstant());
}
else if (expr instanceof SingleRowMethodExpression) {
SingleRowMethodExpression single = (SingleRowMethodExpression) expr;
if ((single.getChain() == null) || (single.getChain().size() == 0)) {
throw new IllegalArgumentException("Single row method expression requires one or more method calls");
}
List<ExprChainedSpec> chain = mapChains(single.getChain(), mapContext);
String functionName = chain.get(0).getName();
Pair<Class, String> pair;
try
{
pair = mapContext.getEngineImportService().resolveSingleRow(functionName);
}
catch (Exception e)
{
throw new IllegalArgumentException("Function name '" + functionName + "' cannot be resolved to a single-row function: " + e.getMessage(), e);
}
chain.get(0).setName(pair.getSecond());
return new ExprPlugInSingleRowNode(functionName, pair.getFirst(), chain, false);
}
else if (expr instanceof PlugInProjectionExpression)
{
PlugInProjectionExpression node = (PlugInProjectionExpression) expr;
// first try the configured aggregation
try
{
AggregationSupport aggregation = mapContext.getEngineImportService().resolveAggregation(node.getFunctionName());
return new ExprPlugInAggFunctionNode(node.isDistinct(), aggregation, node.getFunctionName());
}
catch (Exception e)
{
// then try the builtin aggregation
ExprNode exprNode = mapContext.getEngineImportService().resolveAggExtendedBuiltin(node.getFunctionName(), node.isDistinct());
if (exprNode != null) {
return exprNode;
}
throw new EPException("Error resolving aggregation: " + e.getMessage(), e);
}
}
else if (expr instanceof OrderedObjectParamExpression)
{
OrderedObjectParamExpression order = (OrderedObjectParamExpression) expr;