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

Reply via email to