[CALCITE-7112] Eliminate nested calls for idempotent unary functions upper/lower/abs

Author: xuzifu666

core/src/main/java/org/apache/calcite/rex/RexSimplify.java

@@ -55,6 +55,7 @@
 
 import java.math.BigDecimal;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.BitSet;
 import java.util.Collection;
 import java.util.Collections;
@@ -88,6 +89,9 @@ public class RexSimplify {
 
   private static final Strong STRONG = new Strong();
 
+  private static final List<SqlOperator> IDEMOTENT_UNARY_FUNCTIONS =
+      Arrays.asList(SqlStdOperatorTable.UPPER, SqlStdOperatorTable.LOWER, SqlStdOperatorTable.ABS);
+
   /**
    * Creates a RexSimplify.
    *
@@ -333,7 +337,9 @@ RexNode simplify(RexNode e, RexUnknownAs unknownAs) {
       return simplifyM2v((RexCall) e);
     default:
       if (e.getClass() == RexCall.class) {
-        return simplifyGenericNode((RexCall) e);
+        RexCall rexCall = (RexCall) e;
+        rexCall = simplifUnaryFunction(rexCall);
+        return simplifyGenericNode(rexCall);
       } else {
         return e;
       }
@@ -397,6 +403,22 @@ RexNode isFalse(RexNode e) {
         : rexBuilder.makeCall(SqlStdOperatorTable.IS_FALSE, e);
   }
 
+  /**
+   * Runs simplification unary function by eliminating idempotent.
+   */
+  private RexCall simplifUnaryFunction(RexCall rexCall) {
+    while (IDEMOTENT_UNARY_FUNCTIONS.contains(rexCall.getOperator())
+        && rexCall.getOperands().get(0) instanceof RexCall) {
+      RexCall subRexCall = (RexCall) rexCall.getOperands().get(0);
+      if (rexCall.getOperator() == subRexCall.getOperator()) {
+        rexCall = subRexCall;
+      } else {
+        break;
+      }
+    }
+    return rexCall;
+  }
+
   /**
    * Runs simplification inside a non-specialized node.
    */

core/src/test/java/org/apache/calcite/test/RexImplicationCheckerTest.java

@@ -24,6 +24,7 @@
 import org.apache.calcite.rex.RexSimplify;
 import org.apache.calcite.rex.RexUnknownAs;
 import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.SqlOperator;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.util.DateString;
@@ -35,9 +36,13 @@
 
 import org.junit.jupiter.api.Test;
 
+import java.util.Arrays;
+import java.util.List;
+
 import static org.apache.calcite.test.RexImplicationCheckerFixtures.Fixture;
 
 import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.hasToString;
 
@@ -361,6 +366,57 @@ public class RexImplicationCheckerTest {
         hasToString("2014"));
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-7112">[CALCITE-7112]
+   * Eliminate nested calls for idempotent unary functions upper/lower/abs</a>. */
+  @Test void testSimplifyIdempotentUnaryFunctions() {
+    // test for upper/lower functions
+    final Fixture f = new Fixture();
+    List<SqlOperator> testOeratorList =
+        Arrays.asList(SqlStdOperatorTable.UPPER, SqlStdOperatorTable.LOWER);
+    for (SqlOperator operator : testOeratorList) {
+      RexCall innerCall =
+          (RexCall) f.rexBuilder
+              .makeCall(operator, f.rexBuilder.makeLiteral("Calcite Test"));
+      RexCall outerCall =
+          (RexCall) f.rexBuilder.makeCall(operator, innerCall);
+      RexCall simplifiedInnerCall =
+          (RexCall) f.simplify.simplifyPreservingType(outerCall,
+              RexUnknownAs.UNKNOWN, true);
+
+      assertThat(((RexLiteral) simplifiedInnerCall.getOperands().get(0))
+              .getValue(),
+          is(((RexLiteral) innerCall.getOperands().get(0)).getValue()));
+    }
+
+    // test for abs function
+    RelDataType intType = f.rexBuilder.getTypeFactory().createSqlType(SqlTypeName.INTEGER);
+    RexCall innerCall =
+        (RexCall) f.rexBuilder
+            .makeCall(SqlStdOperatorTable.ABS, f.rexBuilder.makeLiteral(12, intType));
+    RexCall outerCall =
+        (RexCall) f.rexBuilder
+            .makeCall(SqlStdOperatorTable.ABS, innerCall);
+    RexCall simplifiedInnerCall =
+        (RexCall) f.simplify.simplifyPreservingType(outerCall,
+            RexUnknownAs.UNKNOWN, true);
+
+    assertThat(((RexLiteral) simplifiedInnerCall.getOperands().get(0)).getValue(),
+        is(((RexLiteral) innerCall.getOperands().get(0)).getValue()));
+
+    // negative test
+    innerCall = (RexCall) f.rexBuilder
+        .makeCall(SqlStdOperatorTable.UPPER, f.rexBuilder.makeLiteral("Calcite Test"));
+    outerCall = (RexCall) f.rexBuilder.makeCall(SqlStdOperatorTable.LOWER, innerCall);
+    simplifiedInnerCall = (RexCall) f.simplify
+        .simplifyPreservingType(outerCall, RexUnknownAs.UNKNOWN, true);
+
+    assertThat(simplifiedInnerCall.getOperands().get(0),
+        not(((RexLiteral) innerCall.getOperands().get(0)).getValue()));
+    assertThat(((RexCall) simplifiedInnerCall.getOperands().get(0)).getOperands().get(0),
+        is(innerCall.getOperands().get(0)));
+  }
+
   /** Test case for
    * <a href="https://issues.apache.org/jira/browse/CALCITE-7042">[CALCITE-7042]
    * Eliminate nested TRIM calls, exploiting the fact that TRIM is idempotent</a>. */