[CALCITE-7122] Eliminate nested calls for idempotent unary functions UPPER/LOWER/ABS/INITCAP

Author: xuzifu666

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

@@ -88,6 +88,12 @@ public class RexSimplify {
 
   private static final Strong STRONG = new Strong();
 
+  private static final ImmutableList<SqlOperator> IDEMOTENT_UNARY_FUNCTIONS =
+      ImmutableList.of(SqlStdOperatorTable.UPPER,
+          SqlStdOperatorTable.LOWER,
+          SqlStdOperatorTable.INITCAP,
+          SqlStdOperatorTable.ABS);
+
   /**
    * Creates a RexSimplify.
    *
@@ -333,7 +339,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 = simplifyIdempotentUnaryFunction(rexCall);
+        return simplifyGenericNode(rexCall);
       } else {
         return e;
       }
@@ -397,6 +405,22 @@ RexNode isFalse(RexNode e) {
         : rexBuilder.makeCall(SqlStdOperatorTable.IS_FALSE, e);
   }
 
+  /**
+   * Runs simplification unary function by eliminating idempotent.
+   */
+  private RexCall simplifyIdempotentUnaryFunction(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,73 @@ public class RexImplicationCheckerTest {
         hasToString("2014"));
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-7122">[CALCITE-7122]
+   * Eliminate nested calls for idempotent unary functions UPPER/LOWER/ABS/INITCAP</a>. */
+  @Test void testSimplifyIdempotentUnaryFunctions() {
+    // Test that:
+    // upper(upper(x)) is simplied to upper(x)
+    // lower(upper(x)) is simplied to lower(x)
+    // initcap(upper(x)) is simplied to initcap(x)
+    final Fixture f = new Fixture();
+    List<SqlOperator> testOeratorList =
+        Arrays.asList(SqlStdOperatorTable.UPPER,
+            SqlStdOperatorTable.LOWER,
+            SqlStdOperatorTable.INITCAP);
+    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 that abs(abs(x)) is simplied to abs(x)
+    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()));
+
+    // Test that max(abs(abs(x))) is simplied to max(abs(x))
+    RexCall maxCall =
+        (RexCall) f.rexBuilder
+            .makeCall(SqlStdOperatorTable.MAX, outerCall);
+    simplifiedInnerCall =
+        (RexCall) f.simplify.simplifyPreservingType(maxCall,
+            RexUnknownAs.UNKNOWN, true);
+    assertThat(simplifiedInnerCall.getOperator(), is(SqlStdOperatorTable.MAX));
+    assertThat(simplifiedInnerCall.getOperands().get(0), is(innerCall));
+    assertThat(simplifiedInnerCall.getOperands().get(0), not(outerCall));
+
+    // 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>. */