tkhurana commented on code in PR #2239: URL: https://github.com/apache/phoenix/pull/2239#discussion_r2241075085
########## phoenix-core-client/src/main/java/org/apache/phoenix/compile/WhereOptimizer.java: ########## @@ -1945,6 +1948,150 @@ public KeySlots visitLeave(InListExpression node, List<KeySlots> childParts) { return newKeyParts(childSlot, node, new ArrayList<KeyRange>(ranges)); } + /** + * If {@link ArrayAnyComparisonExpression} is of the form: + * + * <pre> + * COL = ANY(ARR) + * </pre> + * + * then we can extract the scan ranges for the COL, given COL is a PK column. This syntactical + * pattern can be used as a replacement for a IN expression. So, instead of following IN + * expression: + * + * <pre> + * COL IN (VAL1, VAL2, ... VALN) + * </pre> + * + * we can use the following ANY expression: + * + * <pre> + * try (Connection conn = DriverManager.getConnection(url)) { + * conn.createArrayOf("CHAR", new String[] {"VAL1", "VAL2", ... "VALN"}); + * try (PreparedStatement stmt = conn.prepareStatement( + * "SELECT ... FROM TABLE WHERE COL = ANY(?)")) { + * stmt.setArray(1, arr); + * ResultSet rs = stmt.executeQuery(); + * } + * } + * </pre> + * + * This will help in saving the query parsing time as on using IN list query parsing time + * increases with the size of IN list but in case of ANY expression it is constant. Below we + * account for cases where COL is on the LHS or RHS of the comparison expression. + * @param node {@link ArrayAnyComparisonExpression} node for which scan ranges are to + * be extracted + * @param keyExpressions {@link RowKeyColumnExpression} for the PK column for which scan ranges + * are to be extracted + * @return true if the scan ranges can be extracted, false otherwise + */ + private boolean prepareForArrayAnyComparisonKeySlots(ArrayAnyComparisonExpression node, + List<Expression> keyExpressions) { + // {@link ArrayAnyComparisonExpression} has two children, and the second child is + // comparison expression + Expression childExpr = node.getChildren().get(1); + if (!(childExpr instanceof ComparisonExpression)) { + return false; + } + ComparisonExpression comparisonExpr = (ComparisonExpression) childExpr; + + // Replacing IN() with =ANY() is only valid if the comparison operator is EQUAL + if (comparisonExpr.getFilterOp() != CompareOperator.EQUAL) { + return false; + } + + // {@link ComparisonExpression} will have two children in this case, we need to make + // sure that one of them is a {@link RowKeyColumnExpression} and the other is a {@link + // ArrayElemRefExpression}. Further, the first child of {@link ArrayElemRefExpression} + // must be a {@link LiteralExpression}. The first child of {@link + // ArrayElemRefExpression} is same as the first child of {@link + // ArrayAnyComparisonExpression}. + Expression lhs = comparisonExpr.getChildren().get(0); + Expression rhs = comparisonExpr.getChildren().get(1); + if (lhs instanceof RowKeyColumnExpression && rhs instanceof ArrayElemRefExpression) { Review Comment: What if the RowKeyColumnExpression is embedded inside another expression like CoerceExpression. That should not have any impact on the scan range generated. -- 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. To unsubscribe, e-mail: issues-unsubscr...@phoenix.apache.org For queries about this service, please contact Infrastructure at: us...@infra.apache.org