SQL: Test IN operator out of range validation (#64546)

Additional tests.

Test if the type of the field is actually picked up from the field
mapping and if the values specified for the `IN` operator are
converter to the type of the field (for numerical fields).

Relates to #64238

Author: Andras Palinkas

x-pack/plugin/sql/src/test/java/org/elasticsearch/xpack/sql/planner/QueryTranslatorTests.java

@@ -99,48 +99,76 @@
 import static org.elasticsearch.xpack.sql.planner.QueryTranslator.DATE_FORMAT;
 import static org.elasticsearch.xpack.sql.planner.QueryTranslator.TIME_FORMAT;
 import static org.elasticsearch.xpack.sql.type.SqlDataTypes.DATE;
-import static org.elasticsearch.xpack.sql.util.DateUtils.UTC;
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.Matchers.endsWith;
 import static org.hamcrest.Matchers.everyItem;
 import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.startsWith;
 
 public class QueryTranslatorTests extends ESTestCase {
 
-    private static SqlFunctionRegistry sqlFunctionRegistry;
-    private static SqlParser parser;
-    private static Analyzer analyzer;
-    private static Optimizer optimizer;
-    private static Planner planner;
+    private static class TestContext {
+        private SqlFunctionRegistry sqlFunctionRegistry;
+        private SqlParser parser;
+        private Analyzer analyzer;
+        private Optimizer optimizer;
+        private Planner planner;
+
+        TestContext(String mappingFile) {
+            parser = new SqlParser();
+            sqlFunctionRegistry = new SqlFunctionRegistry();
+
+            Map<String, EsField> mapping = SqlTypesTests.loadMapping(mappingFile);
+            EsIndex test = new EsIndex("test", mapping);
+            IndexResolution getIndexResult = IndexResolution.valid(test);
+            analyzer = new Analyzer(SqlTestUtils.TEST_CFG, sqlFunctionRegistry, getIndexResult, new Verifier(new Metrics()));
+            optimizer = new Optimizer();
+            planner = new Planner();
+        }
+
+        public LogicalPlan plan(String sql) {
+            return plan(sql, DateUtils.UTC);
+        }
+
+        public LogicalPlan plan(String sql, ZoneId zoneId) {
+            return analyzer.analyze(parser.createStatement(sql, zoneId), true);
+        }
+
+        private PhysicalPlan optimizeAndPlan(String sql) {
+            return optimizeAndPlan(plan(sql));
+        }
+
+        private PhysicalPlan optimizeAndPlan(LogicalPlan plan) {
+            return planner.plan(optimizer.optimize(plan),true);
+        }
+
+        private LogicalPlan parameterizedSql(String sql, SqlTypedParamValue... params) {
+            return analyzer.analyze(parser.createStatement(sql, Arrays.asList(params), DateUtils.UTC), true);
+        }
+    }
+
+    private static TestContext defaultTestContext;
 
     @BeforeClass
     public static void init() {
-        parser = new SqlParser();
-        sqlFunctionRegistry = new SqlFunctionRegistry();
-
-        Map<String, EsField> mapping = SqlTypesTests.loadMapping("mapping-multi-field-variation.json");
-        EsIndex test = new EsIndex("test", mapping);
-        IndexResolution getIndexResult = IndexResolution.valid(test);
-        analyzer = new Analyzer(SqlTestUtils.TEST_CFG, sqlFunctionRegistry, getIndexResult, new Verifier(new Metrics()));
-        optimizer = new Optimizer();
-        planner = new Planner();
+        defaultTestContext = new TestContext("mapping-multi-field-variation.json");
     }
 
     private LogicalPlan plan(String sql) {
-        return plan(sql, UTC);
+        return defaultTestContext.plan(sql, DateUtils.UTC);
     }
 
     private LogicalPlan plan(String sql, ZoneId zoneId) {
-        return analyzer.analyze(parser.createStatement(sql, zoneId), true);
+        return defaultTestContext.plan(sql, zoneId);
     }
 
     private PhysicalPlan optimizeAndPlan(String sql) {
-        return optimizeAndPlan(plan(sql));
+        return defaultTestContext.optimizeAndPlan(sql);
     }
 
     private PhysicalPlan optimizeAndPlan(LogicalPlan plan) {
-        return planner.plan(optimizer.optimize(plan),true);
+        return defaultTestContext.optimizeAndPlan(plan);
     }
 
     private QueryTranslation translate(Expression condition) {
@@ -152,7 +180,7 @@ private QueryTranslation translateWithAggs(Expression condition) {
     }
 
     private LogicalPlan parameterizedSql(String sql, SqlTypedParamValue... params) {
-        return analyzer.analyze(parser.createStatement(sql, Arrays.asList(params), org.elasticsearch.xpack.ql.type.DateUtils.UTC), true);
+        return defaultTestContext.parameterizedSql(sql, params);
     }
 
     public void testTermEqualityAnalyzer() {
@@ -426,7 +454,7 @@ private void testDateRangeWithCurrentFunctions_AndRangeOptimization(String funct
         assertEquals(lowerOperator.equals("<="), rq.includeUpper());
         assertEquals(upperOperator.equals(">="), rq.includeLower());
         assertEquals(pattern, rq.format());
-        assertEquals(UTC, rq.zoneId());
+        assertEquals(DateUtils.UTC, rq.zoneId());
     }
 
     public void testDateRangeWithESDateMath() {
@@ -2104,7 +2132,7 @@ public void testHavingWithColumnImplicitGrouping() {
     }
 
     public void testScriptsInsideAggregateFunctions() {
-        for (FunctionDefinition fd : sqlFunctionRegistry.listFunctions()) {
+        for (FunctionDefinition fd : defaultTestContext.sqlFunctionRegistry.listFunctions()) {
             if (AggregateFunction.class.isAssignableFrom(fd.clazz()) && (MatrixStatsEnclosed.class.isAssignableFrom(fd.clazz()) == false)) {
                 String aggFunction = fd.name() + "(ABS((int * 10) / 3) + 1";
                 if (fd.clazz() == Percentile.class || fd.clazz() == PercentileRank.class) {
@@ -2142,7 +2170,7 @@ public void testScriptsInsideAggregateFunctions() {
     }
 
     public void testScriptsInsideAggregateFunctions_WithHaving() {
-        for (FunctionDefinition fd : sqlFunctionRegistry.listFunctions()) {
+        for (FunctionDefinition fd : defaultTestContext.sqlFunctionRegistry.listFunctions()) {
             if (AggregateFunction.class.isAssignableFrom(fd.clazz())
                     && (MatrixStatsEnclosed.class.isAssignableFrom(fd.clazz()) == false)
                     // First/Last don't support having: https://github.com/elastic/elasticsearch/issues/37938
@@ -2195,7 +2223,7 @@ public void testScriptsInsideAggregateFunctions_ConvertedToStats() {
     }
 
     public void testScriptsInsideAggregateFunctions_ExtendedStats() {
-        for (FunctionDefinition fd : sqlFunctionRegistry.listFunctions()) {
+        for (FunctionDefinition fd : defaultTestContext.sqlFunctionRegistry.listFunctions()) {
             if (ExtendedStatsEnclosed.class.isAssignableFrom(fd.clazz())) {
                 String aggFunction = fd.name() + "(ABS((int * 10) / 3) + 1)";
                 PhysicalPlan p = optimizeAndPlan("SELECT " + aggFunction + " FROM test");
@@ -2298,4 +2326,16 @@ public void testSameExpressionWithoutAlias() {
         // these two should be semantically different reference attributes
         assertNotEquals(eqe.output().get(0).id(), eqe.output().get(1).id());
     }
+
+    public void testInOutOfRangeValues() {
+        QlIllegalArgumentException ex = expectThrows(QlIllegalArgumentException.class,
+            () -> optimizeAndPlan("SELECT int FROM test WHERE int IN (1, 2, 3, " + Long.MAX_VALUE + ", 5, 6, 7)"));
+        assertThat(ex.getMessage(), is("[" + Long.MAX_VALUE + "] out of [integer] range"));
+    }
+
+    public void testInInRangeValues() {
+        TestContext testContext = new TestContext("mapping-numeric.json");
+        PhysicalPlan p = testContext.optimizeAndPlan("SELECT long FROM test WHERE long IN (1, 2, 3, " + Long.MAX_VALUE + ", 5, 6, 7)");
+        assertEquals(EsQueryExec.class, p.getClass());
+    }
 }