use of org.drools.mvel.parser.ast.expr.HalfBinaryExpr in project drools by kiegroup.
the class ConstraintParser method parseBinaryExpr.
private DrlxParseResult parseBinaryExpr(BinaryExpr binaryExpr, Class<?> patternType, String bindingId, ConstraintExpression constraint, Expression drlxExpr, boolean hasBind, boolean isPositional, boolean isEnclosed) {
BinaryExpr.Operator operator = binaryExpr.getOperator();
boolean isOrBinary = operator == BinaryExpr.Operator.OR;
if (isLogicalOperator(operator) && isCombinable(binaryExpr)) {
DrlxParseResult leftResult = compileToJavaRecursive(patternType, bindingId, constraint, binaryExpr.getLeft(), hasBind, isPositional);
Expression rightExpr = binaryExpr.getRight() instanceof HalfPointFreeExpr ? completeHalfExpr(((PointFreeExpr) binaryExpr.getLeft()).getLeft(), (HalfPointFreeExpr) binaryExpr.getRight()) : binaryExpr.getRight();
DrlxParseResult rightResult = compileToJavaRecursive(patternType, bindingId, constraint, rightExpr, hasBind, isPositional);
return isMultipleResult(leftResult, operator, rightResult) ? createMultipleDrlxParseSuccess(operator, (DrlxParseSuccess) leftResult, (DrlxParseSuccess) rightResult) : leftResult.combineWith(rightResult, operator);
}
final ExpressionTyperContext expressionTyperContext = new ExpressionTyperContext();
final ExpressionTyper expressionTyper = new ExpressionTyper(context, patternType, bindingId, isPositional, expressionTyperContext);
TypedExpressionResult leftTypedExpressionResult = expressionTyper.toTypedExpression(binaryExpr.getLeft());
Optional<TypedExpression> optLeft = leftTypedExpressionResult.getTypedExpression();
if (!optLeft.isPresent()) {
return new DrlxParseFail();
}
TypedExpression left = optLeft.get();
List<String> usedDeclarationsOnLeft = hasBind ? new ArrayList<>(expressionTyperContext.getUsedDeclarations()) : null;
List<Expression> leftPrefixExpressions = new ArrayList<>();
if (isOrBinary) {
leftPrefixExpressions.addAll(expressionTyperContext.getNullSafeExpressions());
expressionTyperContext.getNullSafeExpressions().clear();
leftPrefixExpressions.addAll(expressionTyperContext.getPrefixExpresssions());
expressionTyperContext.getPrefixExpresssions().clear();
}
List<Expression> rightPrefixExpresssions = new ArrayList<>();
TypedExpression right;
if (constraint.isNameClashingUnification()) {
String name = constraint.getUnificationField();
right = new TypedExpression(new NameExpr(name), left.getType());
expressionTyperContext.addUsedDeclarations(name);
} else {
TypedExpressionResult rightExpressionResult = expressionTyper.toTypedExpression(binaryExpr.getRight());
Optional<TypedExpression> optRight = rightExpressionResult.getTypedExpression();
if (!optRight.isPresent()) {
return new DrlxParseFail(new ParseExpressionErrorResult(drlxExpr));
}
right = optRight.get();
if (isOrBinary) {
rightPrefixExpresssions.addAll(expressionTyperContext.getNullSafeExpressions());
expressionTyperContext.getNullSafeExpressions().clear();
rightPrefixExpresssions.addAll(expressionTyperContext.getPrefixExpresssions());
expressionTyperContext.getPrefixExpresssions().clear();
}
}
boolean equalityExpr = operator == EQUALS || operator == NOT_EQUALS;
CoercedExpression.CoercedExpressionResult coerced;
try {
coerced = new CoercedExpression(left, right, equalityExpr).coerce();
} catch (CoercedExpression.CoercedExpressionException e) {
return new DrlxParseFail(e.getInvalidExpressionErrorResult());
}
left = coerced.getCoercedLeft();
right = getCoercedRightExpression(packageModel, coerced);
Expression combo;
boolean arithmeticExpr = asList(PLUS, MINUS, MULTIPLY, DIVIDE, REMAINDER).contains(operator);
boolean isBetaConstraint = right.getExpression() != null && hasNonGlobalDeclaration(expressionTyperContext);
boolean requiresSplit = operator == BinaryExpr.Operator.AND && binaryExpr.getRight() instanceof HalfBinaryExpr && !isBetaConstraint;
if (equalityExpr) {
combo = getEqualityExpression(left, right, operator).expression;
} else if (arithmeticExpr && (left.isBigDecimal())) {
ConstraintCompiler constraintCompiler = createConstraintCompiler(this.context, of(patternType));
CompiledExpressionResult compiledExpressionResult = constraintCompiler.compileExpression(binaryExpr);
combo = compiledExpressionResult.getExpression();
} else {
if (left.getExpression() == null || right.getExpression() == null) {
return new DrlxParseFail(new ParseExpressionErrorResult(drlxExpr));
}
// This special comparisons
SpecialComparisonResult specialComparisonResult = handleSpecialComparisonCases(expressionTyper, operator, left, right);
combo = specialComparisonResult.expression;
left = requiresSplit ? left : specialComparisonResult.coercedLeft;
right = requiresSplit ? right : specialComparisonResult.coercedRight;
}
if (isOrBinary) {
// NullSafeExpressions are combined here because the order is complex
combo = combineExpressions(leftPrefixExpressions, rightPrefixExpresssions, combo);
} else {
// NullSafeExpressions will be added later by PatternDSL.addNullSafeExpr() which will be separated AlphaNodes
combo = combineExpressions(leftTypedExpressionResult, combo);
}
boolean isPredicate = isPredicateBooleanExpression(binaryExpr);
if (isEnclosed && !isPredicate) {
combo = new EnclosedExpr(combo);
}
Index.ConstraintType constraintType = DrlxParseUtil.toConstraintType(operator);
if (isForallSelfJoinConstraint(left, right, constraintType)) {
constraintType = Index.ConstraintType.FORALL_SELF_JOIN;
}
return new SingleDrlxParseSuccess(patternType, bindingId, combo, isBooleanOperator(operator) ? boolean.class : left.getType()).setDecodeConstraintType(constraintType).setUsedDeclarations(expressionTyperContext.getUsedDeclarations()).setUsedDeclarationsOnLeft(usedDeclarationsOnLeft).setUnification(constraint.isUnification()).setReactOnProperties(expressionTyperContext.getReactOnProperties()).setLeft(left).setRight(right).setBetaConstraint(isBetaConstraint).setRequiresSplit(requiresSplit).setIsPredicate(isPredicate).setImplicitCastExpression(leftTypedExpressionResult.getInlineCastExpression()).setNullSafeExpressions(// This would be empty if NullSafeExpressions were combined earlier
leftTypedExpressionResult.getNullSafeExpressions());
}
use of org.drools.mvel.parser.ast.expr.HalfBinaryExpr in project drools by kiegroup.
the class DroolsMvelParserTest method testAndWithImplicitParameterAndParenthesisComplexOnField.
@Test
public void testAndWithImplicitParameterAndParenthesisComplexOnField() {
String expr = "value.length ((> 1 && < 2) || (> 3 && < 4))";
Expression expression = parseExpression(parser, expr).getExpr();
BinaryExpr comboExpr = ((BinaryExpr) expression);
assertEquals(Operator.OR, comboExpr.getOperator());
BinaryExpr comboExprLeft = ((BinaryExpr) comboExpr.getLeft());
assertEquals(Operator.AND, comboExprLeft.getOperator());
BinaryExpr first = (BinaryExpr) comboExprLeft.getLeft();
assertTrue(first.getLeft() instanceof FieldAccessExpr);
assertEquals("value.length", toString(first.getLeft()));
assertEquals("1", toString(first.getRight()));
assertEquals(Operator.GREATER, first.getOperator());
HalfBinaryExpr second = (HalfBinaryExpr) comboExprLeft.getRight();
assertEquals("2", toString(second.getRight()));
assertEquals(HalfBinaryExpr.Operator.LESS, second.getOperator());
BinaryExpr comboExprRight = ((BinaryExpr) comboExpr.getRight());
assertEquals(Operator.AND, comboExprRight.getOperator());
BinaryExpr third = (BinaryExpr) comboExprRight.getLeft();
assertEquals("value.length", toString(third.getLeft()));
assertEquals("3", toString(third.getRight()));
assertEquals(Operator.GREATER, third.getOperator());
HalfBinaryExpr forth = (HalfBinaryExpr) comboExprRight.getRight();
assertEquals("4", toString(forth.getRight()));
assertEquals(HalfBinaryExpr.Operator.LESS, forth.getOperator());
}
use of org.drools.mvel.parser.ast.expr.HalfBinaryExpr in project drools by kiegroup.
the class DroolsMvelParserTest method testAndWithImplicitNegativeParameter.
@Test
public void testAndWithImplicitNegativeParameter() {
String expr = "value > -2 && < -1";
Expression expression = parseExpression(parser, expr).getExpr();
BinaryExpr comboExpr = ((BinaryExpr) expression);
assertEquals(Operator.AND, comboExpr.getOperator());
BinaryExpr first = (BinaryExpr) comboExpr.getLeft();
assertEquals("value", toString(first.getLeft()));
assertEquals("-2", toString(first.getRight()));
assertEquals(Operator.GREATER, first.getOperator());
HalfBinaryExpr second = (HalfBinaryExpr) comboExpr.getRight();
assertEquals("-1", toString(second.getRight()));
assertEquals(HalfBinaryExpr.Operator.LESS, second.getOperator());
}
use of org.drools.mvel.parser.ast.expr.HalfBinaryExpr in project drools by kiegroup.
the class DroolsMvelParserTest method testOrWithImplicitParameter.
@Test
public void testOrWithImplicitParameter() {
String expr = "name == \"Mark\" || == \"Mario\" || == \"Luca\"";
Expression expression = parseExpression(parser, expr).getExpr();
BinaryExpr comboExpr = ((BinaryExpr) expression);
assertEquals(Operator.OR, comboExpr.getOperator());
BinaryExpr first = ((BinaryExpr) ((BinaryExpr) comboExpr.getLeft()).getLeft());
assertEquals("name", toString(first.getLeft()));
assertEquals("\"Mark\"", toString(first.getRight()));
assertEquals(Operator.EQUALS, first.getOperator());
HalfBinaryExpr second = (HalfBinaryExpr) ((BinaryExpr) comboExpr.getLeft()).getRight();
assertEquals("\"Mario\"", toString(second.getRight()));
assertEquals(HalfBinaryExpr.Operator.EQUALS, second.getOperator());
HalfBinaryExpr third = (HalfBinaryExpr) comboExpr.getRight();
assertEquals("\"Luca\"", toString(third.getRight()));
assertEquals(HalfBinaryExpr.Operator.EQUALS, third.getOperator());
}
use of org.drools.mvel.parser.ast.expr.HalfBinaryExpr in project drools by kiegroup.
the class DroolsMvelParserTest method testUnsupportedImplicitParameter.
@Test
public /* This shouldn't be supported, an HalfBinaryExpr should be valid only after a && or a || */
void testUnsupportedImplicitParameter() {
String expr = "== \"Mark\"";
Expression expression = parseExpression(parser, expr).getExpr();
assertTrue(expression instanceof HalfBinaryExpr);
assertEquals(expr, printNode(expression));
}
Aggregations