Add more UTs

Author: julian-elastic

x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/optimizer/LocalLogicalPlanOptimizerTests.java

@@ -37,7 +37,9 @@
 import org.elasticsearch.xpack.esql.expression.function.scalar.nulls.Coalesce;
 import org.elasticsearch.xpack.esql.expression.function.scalar.string.StartsWith;
 import org.elasticsearch.xpack.esql.expression.function.scalar.string.regex.RLike;
+import org.elasticsearch.xpack.esql.expression.function.scalar.string.regex.RLikeList;
 import org.elasticsearch.xpack.esql.expression.function.scalar.string.regex.WildcardLike;
+import org.elasticsearch.xpack.esql.expression.function.scalar.string.regex.WildcardLikeList;
 import org.elasticsearch.xpack.esql.expression.predicate.logical.And;
 import org.elasticsearch.xpack.esql.expression.predicate.nulls.IsNotNull;
 import org.elasticsearch.xpack.esql.expression.predicate.operator.arithmetic.Add;
@@ -665,6 +667,26 @@ public void testReplaceUpperStringCasinqgWithInsensitiveRLike() {
         var source = as(filter.child(), EsRelation.class);
     }
 
+    /*
+     *Limit[1000[INTEGER],false]
+     * \_Filter[RLikeList(first_name{f}#4, "("VALÜ*", "VALÜAA*")", true)]
+     *  \_EsRelation[test][_meta_field{f}#9, emp_no{f}#3, first_name{f}#4, gen..]
+     */
+    public void testReplaceUpperStringCasinqWithInsensitiveRLikeList() {
+        var plan = localPlan("FROM test | WHERE TO_UPPER(TO_LOWER(TO_UPPER(first_name))) RLIKE (\"VALÜ*\", \"TEST*\")");
+
+        var limit = as(plan, Limit.class);
+        var filter = as(limit.child(), Filter.class);
+        var rLikeList = as(filter.condition(), RLikeList.class);
+        var field = as(rLikeList.field(), FieldAttribute.class);
+        assertThat(field.fieldName().string(), is("first_name"));
+        assertEquals(2, rLikeList.pattern().patternList().size());
+        assertThat(rLikeList.pattern().patternList().get(0).pattern(), is("VALÜ*"));
+        assertThat(rLikeList.pattern().patternList().get(1).pattern(), is("TEST*"));
+        assertThat(rLikeList.caseInsensitive(), is(true));
+        var source = as(filter.child(), EsRelation.class);
+    }
+
     // same plan as above, but lower case pattern
     public void testReplaceLowerStringCasingWithInsensitiveRLike() {
         var plan = localPlan("FROM test | WHERE TO_LOWER(TO_UPPER(first_name)) RLIKE \"valü*\"");
@@ -679,6 +701,35 @@ public void testReplaceLowerStringCasingWithInsensitiveRLike() {
         var source = as(filter.child(), EsRelation.class);
     }
 
+    // same plan as above, but lower case pattern and list of patterns
+    public void testReplaceLowerStringCasingWithInsensitiveRLikeList() {
+        var plan = localPlan("FROM test | WHERE TO_LOWER(TO_UPPER(first_name)) RLIKE (\"valü*\", \"test*\")");
+        var limit = as(plan, Limit.class);
+        var filter = as(limit.child(), Filter.class);
+        var rLikeList = as(filter.condition(), RLikeList.class);
+        var field = as(rLikeList.field(), FieldAttribute.class);
+        assertThat(field.fieldName().string(), is("first_name"));
+        assertEquals(2, rLikeList.pattern().patternList().size());
+        assertThat(rLikeList.pattern().patternList().get(0).pattern(), is("valü*"));
+        assertThat(rLikeList.pattern().patternList().get(1).pattern(), is("test*"));
+        assertThat(rLikeList.caseInsensitive(), is(true));
+        var source = as(filter.child(), EsRelation.class);
+    }
+
+    // same plan as above, but lower case pattern and list of patterns, one of which is upper case
+    public void testReplaceLowerStringCasingWithMixedCaseRLikeList() {
+        var plan = localPlan("FROM test | WHERE TO_LOWER(TO_UPPER(first_name)) RLIKE (\"valü*\", \"TEST*\")");
+        var limit = as(plan, Limit.class);
+        var filter = as(limit.child(), Filter.class);
+        var rLikeList = as(filter.condition(), RLikeList.class);
+        var field = as(rLikeList.field(), FieldAttribute.class);
+        assertThat(field.fieldName().string(), is("first_name"));
+        assertEquals(1, rLikeList.pattern().patternList().size());
+        assertThat(rLikeList.pattern().patternList().get(0).pattern(), is("valü*"));
+        assertThat(rLikeList.caseInsensitive(), is(true));
+        var source = as(filter.child(), EsRelation.class);
+    }
+
     /**
      * LocalRelation[[_meta_field{f}#9, emp_no{f}#3, first_name{f}#4, gender{f}#5, hire_date{f}#10, job{f}#11, job.raw{f}#12, langu
      *   ages{f}#6, last_name{f}#7, long_noidx{f}#13, salary{f}#8],EMPTY]
@@ -704,6 +755,37 @@ public void testReplaceUpperStringCasingWithInsensitiveLike() {
         var source = as(filter.child(), EsRelation.class);
     }
 
+    // same plan as in testReplaceUpperStringCasingWithInsensitiveRLikeList, but with LIKE instead of RLIKE
+    public void testReplaceUpperStringCasingWithInsensitiveLikeList() {
+        var plan = localPlan("FROM test | WHERE TO_UPPER(TO_LOWER(TO_UPPER(first_name))) LIKE (\"VALÜ*\", \"TEST*\")");
+
+        var limit = as(plan, Limit.class);
+        var filter = as(limit.child(), Filter.class);
+        var likeList = as(filter.condition(), WildcardLikeList.class);
+        var field = as(likeList.field(), FieldAttribute.class);
+        assertThat(field.fieldName().string(), is("first_name"));
+        assertEquals(2, likeList.pattern().patternList().size());
+        assertThat(likeList.pattern().patternList().get(0).pattern(), is("VALÜ*"));
+        assertThat(likeList.pattern().patternList().get(1).pattern(), is("TEST*"));
+        assertThat(likeList.caseInsensitive(), is(true));
+        var source = as(filter.child(), EsRelation.class);
+    }
+
+    // same plan as above, but mixed case pattern and list of patterns
+    public void testReplaceLowerStringCasingWithMixedCaseLikeList() {
+        var plan = localPlan("FROM test | WHERE TO_LOWER(TO_UPPER(first_name)) RLIKE (\"TEST*\", \"valü*\", \"vaLü*\")");
+        var limit = as(plan, Limit.class);
+        var filter = as(limit.child(), Filter.class);
+        var rLikeList = as(filter.condition(), RLikeList.class);
+        var field = as(rLikeList.field(), FieldAttribute.class);
+        assertThat(field.fieldName().string(), is("first_name"));
+        // only the all lowercase pattern is kept, the mixed case and all uppercase patterns are ignored
+        assertEquals(1, rLikeList.pattern().patternList().size());
+        assertThat(rLikeList.pattern().patternList().get(0).pattern(), is("valü*"));
+        assertThat(rLikeList.caseInsensitive(), is(true));
+        var source = as(filter.child(), EsRelation.class);
+    }
+
     // same plan as above, but lower case pattern
     public void testReplaceLowerStringCasingWithInsensitiveLike() {
         var plan = localPlan("FROM test | WHERE TO_LOWER(TO_UPPER(first_name)) LIKE \"valü*\"");
@@ -729,6 +811,17 @@ public void testReplaceStringCasingAndLikeWithLocalRelation() {
         assertThat(local.supplier(), equalTo(EmptyLocalSupplier.EMPTY));
     }
 
+    /**
+     * LocalRelation[[_meta_field{f}#9, emp_no{f}#3, first_name{f}#4, gender{f}#5, hire_date{f}#10, job{f}#11, job.raw{f}#12, langu
+     *   ages{f}#6, last_name{f}#7, long_noidx{f}#13, salary{f}#8],EMPTY]
+     */
+    public void testReplaceStringCasingAndLikeListWithLocalRelation() {
+        var plan = localPlan("FROM test | WHERE TO_LOWER(TO_UPPER(first_name)) LIKE (\"VALÜ*\", \"TEST*\")");
+
+        var local = as(plan, LocalRelation.class);
+        assertThat(local.supplier(), equalTo(EmptyLocalSupplier.EMPTY));
+    }
+
     /**
      * Limit[1000[INTEGER],false]
      * \_Aggregate[[],[SUM($$integer_long_field$converted_to$long{f$}#5,true[BOOLEAN]) AS sum(integer_long_field::long)#3]]