mayankshriv commented on a change in pull request #5070: Support non-literal
expressions for right-side operand in predicate comparison
URL: https://github.com/apache/incubator-pinot/pull/5070#discussion_r384116619
##########
File path:
pinot-common/src/main/java/org/apache/pinot/sql/parsers/CalciteSqlParser.java
##########
@@ -289,6 +289,91 @@ private static PinotQuery
compileCalciteSqlToPinotQuery(String sql) {
return pinotQuery;
}
+ // This method converts a predicate expression to the what Pinot could
evaluate.
+ // For comparison expression, left operand could be any expression, but
right operand only
+ // supports literal.
+ // E.g. 'WHERE a > b' will be updated to 'WHERE a - b > 0'
+ private static Expression updateComparisonPredicate(Expression expression) {
+ Function functionCall = expression.getFunctionCall();
+ if (functionCall != null) {
+ SqlKind sqlKind = SqlKind.OTHER_FUNCTION;
+ try {
+ sqlKind = SqlKind.valueOf(functionCall.getOperator().toUpperCase());
+ } catch (Exception e) {
+ // Do nothing
+ }
+ switch (sqlKind) {
+ case EQUALS:
+ case NOT_EQUALS:
+ case GREATER_THAN:
+ case GREATER_THAN_OR_EQUAL:
+ case LESS_THAN:
+ case LESS_THAN_OR_EQUAL:
+ // Handle predicate like 'WHERE 10=a'
+ if (functionCall.getOperands().get(0).getLiteral() != null) {
+
functionCall.setOperator(getOppositeOperator(functionCall.getOperator()));
+ List<Expression> oldOperands = functionCall.getOperands();
+ Expression tempExpr = oldOperands.get(0);
+ oldOperands.set(0, oldOperands.get(1));
+ oldOperands.set(1, tempExpr);
+ }
+ if (functionCall.getOperands().get(1).getLiteral() != null) {
+ return expression;
+ }
+ Expression comparisonFunction =
RequestUtils.getFunctionExpression(functionCall.getOperator());
+ List<Expression> exprList = new ArrayList<>();
+ exprList.add(getLeftOperand(functionCall));
+ exprList.add(RequestUtils.getLiteralExpression(0));
+ comparisonFunction.getFunctionCall().setOperands(exprList);
+ return comparisonFunction;
+ default:
+ List<Expression> operands = functionCall.getOperands();
+ List<Expression> newOperands = new ArrayList<>();
+ for (int i = 0; i < operands.size(); i++) {
+ newOperands.add(updateComparisonPredicate(operands.get(i)));
+ }
+ functionCall.setOperands(newOperands);
+ }
+ }
+ return expression;
+ }
+
+ private static String getOppositeOperator(String operator) {
+ switch (operator.toUpperCase()) {
+ case "GREATER_THAN":
Review comment:
Should opposite of GREATER_THAN be LESS_THAN_OR_EQUAL?
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
[email protected]
With regards,
Apache Git Services
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
