Revert "In support (#3)"

This reverts commit 4a5f712

core/src/main/java/com/amazon/opendistroforelasticsearch/sql/ast/dsl/AstDSL.java

@@ -161,10 +161,6 @@ public static Literal timestampLiteral(String value) {
     return literal(value, DataType.TIMESTAMP);
   }
 
-  public static <T> Literal arrayLiteral(List<T> value) {
-    return literal(value, DataType.ARRAY);
-  }
-
   public static Literal doubleLiteral(Double value) {
     return literal(value, DataType.DOUBLE);
   }

core/src/main/java/com/amazon/opendistroforelasticsearch/sql/ast/expression/DataType.java

@@ -37,7 +37,6 @@ public enum DataType {
   DATE(ExprCoreType.DATE),
   TIME(ExprCoreType.TIME),
   TIMESTAMP(ExprCoreType.TIMESTAMP),
-  ARRAY(ExprCoreType.ARRAY),
   INTERVAL(ExprCoreType.INTERVAL);
 
   @Getter

core/src/main/java/com/amazon/opendistroforelasticsearch/sql/ast/expression/In.java

@@ -28,10 +28,7 @@
  * Params include the field expression and/or wildcard field expression,
  * nested field expression (@field).
  * And the values that the field is mapped to (@valueList).
- *
- * @deprecated use function ("in") instead
  */
-@Deprecated
 @Getter
 @ToString
 @EqualsAndHashCode(callSuper = false)

core/src/main/java/com/amazon/opendistroforelasticsearch/sql/data/model/ExprValueUtils.java

@@ -88,7 +88,7 @@ public static ExprValue tupleValue(Map<String, Object> map) {
   /**
    * {@link ExprCollectionValue} constructor.
    */
-  public static <T> ExprValue collectionValue(List<T> list) {
+  public static ExprValue collectionValue(List<Object> list) {
     List<ExprValue> valueList = new ArrayList<>();
     list.forEach(o -> valueList.add(fromObjectValue(o)));
     return new ExprCollectionValue(valueList);
@@ -129,10 +129,6 @@ public static ExprValue fromObjectValue(Object o) {
       return stringValue((String) o);
     } else if (o instanceof Float) {
       return floatValue((Float) o);
-    } else if (o instanceof ExprValue) {
-      // since there is no primitive in Java for differentiating TIMESTAMP DATETIME and DATE
-      // we can allow passing a ExprValue that already contains this information
-      return (ExprValue) o;
     } else {
       throw new ExpressionEvaluationException("unsupported object " + o.getClass());
     }

core/src/main/java/com/amazon/opendistroforelasticsearch/sql/expression/DSL.java

@@ -26,10 +26,8 @@
 import com.amazon.opendistroforelasticsearch.sql.expression.function.BuiltinFunctionName;
 import com.amazon.opendistroforelasticsearch.sql.expression.function.BuiltinFunctionRepository;
 import com.amazon.opendistroforelasticsearch.sql.expression.window.ranking.RankingWindowFunction;
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
-import java.util.List;
 import lombok.RequiredArgsConstructor;
 
 @RequiredArgsConstructor
@@ -254,7 +252,7 @@ public FunctionExpression subtract(Expression... expressions) {
   public FunctionExpression multiply(Expression... expressions) {
     return function(BuiltinFunctionName.MULTIPLY, expressions);
   }
-
+  
   public FunctionExpression adddate(Expression... expressions) {
     return function(BuiltinFunctionName.ADDDATE, expressions);
   }
@@ -366,7 +364,7 @@ public FunctionExpression module(Expression... expressions) {
   public FunctionExpression substr(Expression... expressions) {
     return function(BuiltinFunctionName.SUBSTR, expressions);
   }
-
+  
   public FunctionExpression substring(Expression... expressions) {
     return function(BuiltinFunctionName.SUBSTR, expressions);
   }
@@ -590,19 +588,4 @@ public FunctionExpression castTimestamp(Expression value) {
     return (FunctionExpression) repository
         .compile(BuiltinFunctionName.CAST_TO_TIMESTAMP.getName(), Arrays.asList(value));
   }
-
-  /**
-   * Check that a field is contained in a set of values.
-   */
-  public FunctionExpression in(Expression field, Expression... expressions) {
-    List<Expression> where = new ArrayList<>();
-    where.add(field);
-    where.addAll(Arrays.asList(expressions));
-
-    return function(BuiltinFunctionName.IN, where.toArray(new Expression[0]));
-  }
-
-  public FunctionExpression not_in(Expression field, Expression... expressions) {
-    return not(in(field, expressions));
-  }
 }

core/src/main/java/com/amazon/opendistroforelasticsearch/sql/expression/function/BuiltinFunctionName.java

@@ -106,7 +106,6 @@ public enum BuiltinFunctionName {
   GTE(FunctionName.of(">=")),
   LIKE(FunctionName.of("like")),
   NOT_LIKE(FunctionName.of("not like")),
-  IN(FunctionName.of("in")),
 
   /**
    * Aggregation Function.

core/src/main/java/com/amazon/opendistroforelasticsearch/sql/expression/operator/predicate/BinaryPredicateOperator.java

@@ -19,16 +19,9 @@
 import static com.amazon.opendistroforelasticsearch.sql.data.model.ExprValueUtils.LITERAL_MISSING;
 import static com.amazon.opendistroforelasticsearch.sql.data.model.ExprValueUtils.LITERAL_NULL;
 import static com.amazon.opendistroforelasticsearch.sql.data.model.ExprValueUtils.LITERAL_TRUE;
-import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.ARRAY;
 import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.BOOLEAN;
-import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.DATE;
-import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.DATETIME;
-import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.DOUBLE;
-import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.FLOAT;
 import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.INTEGER;
-import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.LONG;
 import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.STRING;
-import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.TIMESTAMP;
 
 import com.amazon.opendistroforelasticsearch.sql.data.model.ExprBooleanValue;
 import com.amazon.opendistroforelasticsearch.sql.data.model.ExprValue;
@@ -80,7 +73,6 @@ public static void register(BuiltinFunctionRepository repository) {
     repository.register(like());
     repository.register(notLike());
     repository.register(regexp());
-    repository.register(in());
   }
 
   /**
@@ -271,26 +263,6 @@ private static FunctionResolver notLike() {
             STRING));
   }
 
-  private static FunctionResolver in() {
-    return FunctionDSL.define(BuiltinFunctionName.IN.getName(),
-        FunctionDSL.impl(FunctionDSL.nullMissingHandling(OperatorUtils::in),
-            BOOLEAN, INTEGER, ARRAY),
-        FunctionDSL.impl(FunctionDSL.nullMissingHandling(OperatorUtils::in),
-            BOOLEAN, STRING, ARRAY),
-        FunctionDSL.impl(FunctionDSL.nullMissingHandling(OperatorUtils::in),
-            BOOLEAN, LONG, ARRAY),
-        FunctionDSL.impl(FunctionDSL.nullMissingHandling(OperatorUtils::in),
-            BOOLEAN, FLOAT, ARRAY),
-        FunctionDSL.impl(FunctionDSL.nullMissingHandling(OperatorUtils::in),
-            BOOLEAN, DOUBLE, ARRAY),
-        FunctionDSL.impl(FunctionDSL.nullMissingHandling(OperatorUtils::in),
-            BOOLEAN, DATE, ARRAY),
-        FunctionDSL.impl(FunctionDSL.nullMissingHandling(OperatorUtils::in),
-            BOOLEAN, DATETIME, ARRAY),
-        FunctionDSL.impl(FunctionDSL.nullMissingHandling(OperatorUtils::in),
-            BOOLEAN, TIMESTAMP, ARRAY));
-  }
-
   private static ExprValue lookupTableFunction(ExprValue arg1, ExprValue arg2,
                                                Table<ExprValue, ExprValue, ExprValue> table) {
     if (table.contains(arg1, arg2)) {

core/src/main/java/com/amazon/opendistroforelasticsearch/sql/utils/OperatorUtils.java

@@ -15,10 +15,8 @@
 
 package com.amazon.opendistroforelasticsearch.sql.utils;
 
-import com.amazon.opendistroforelasticsearch.sql.data.model.AbstractExprNumberValue;
 import com.amazon.opendistroforelasticsearch.sql.data.model.ExprBooleanValue;
 import com.amazon.opendistroforelasticsearch.sql.data.model.ExprIntegerValue;
-import com.amazon.opendistroforelasticsearch.sql.data.model.ExprStringValue;
 import com.amazon.opendistroforelasticsearch.sql.data.model.ExprValue;
 import java.util.regex.Pattern;
 import lombok.experimental.UtilityClass;
@@ -101,24 +99,4 @@ private static String patternToRegex(String patternString) {
     regex.append('$');
     return regex.toString();
   }
-
-
-  /**
-   * IN (..., ...) operator util.
-   * Expression { expr IN (collection of values..) } is to judge
-   * if expr is contained in a given collection.
-   */
-  public static ExprBooleanValue in(ExprValue expr, ExprValue setOfValues) {
-    return ExprBooleanValue.of(isIn(expr, setOfValues));
-  }
-
-  private static boolean isIn(ExprValue expr, ExprValue setOfValues) {
-    if (expr instanceof AbstractExprNumberValue) {
-      return setOfValues.collectionValue().contains(expr.value());
-    } else if (expr instanceof ExprStringValue) {
-      return setOfValues.collectionValue().contains(expr.stringValue());
-    } else {
-      return setOfValues.collectionValue().contains(expr);
-    }
-  }
 }

core/src/test/java/com/amazon/opendistroforelasticsearch/sql/data/model/ExprValueUtilsTest.java

@@ -215,24 +215,13 @@ public void invalidConvertExprValue(ExprValue value, Function<ExprValue, Object>
     assertThat(exception.getMessage(), Matchers.containsString("invalid"));
   }
 
-  //  disabling test because in case of expr collections, we could pass ExprValues
-  //  @Test
-  //  public void unSupportedObject() {
-  //    Exception exception = assertThrows(ExpressionEvaluationException.class,
-  //        () -> ExprValueUtils.fromObjectValue(integerValue(1)));
-  //    assertEquals(
-  //        "unsupported object "
-  //            + "class com.amazon.opendistroforelasticsearch.sql.data.model.ExprIntegerValue",
-  //        exception.getMessage());
-  //  }
-
   @Test
   public void unSupportedObject() {
     Exception exception = assertThrows(ExpressionEvaluationException.class,
-        () -> ExprValueUtils.fromObjectValue(new Object()));
+        () -> ExprValueUtils.fromObjectValue(integerValue(1)));
     assertEquals(
         "unsupported object "
-            + "class java.lang.Object",
+            + "class com.amazon.opendistroforelasticsearch.sql.data.model.ExprIntegerValue",
         exception.getMessage());
   }
 

core/src/test/java/com/amazon/opendistroforelasticsearch/sql/expression/operator/predicate/BinaryPredicateOperatorTest.java

@@ -27,17 +27,14 @@
 import static com.amazon.opendistroforelasticsearch.sql.data.model.ExprValueUtils.LITERAL_TRUE;
 import static com.amazon.opendistroforelasticsearch.sql.data.model.ExprValueUtils.booleanValue;
 import static com.amazon.opendistroforelasticsearch.sql.data.model.ExprValueUtils.fromObjectValue;
+import static com.amazon.opendistroforelasticsearch.sql.data.model.ExprValueUtils.missingValue;
 import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.BOOLEAN;
-import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.DATE;
-import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.DATETIME;
 import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.INTEGER;
 import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.STRING;
-import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.TIMESTAMP;
 import static com.amazon.opendistroforelasticsearch.sql.utils.ComparisonUtil.compare;
 import static com.amazon.opendistroforelasticsearch.sql.utils.OperatorUtils.matches;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import com.amazon.opendistroforelasticsearch.sql.data.model.ExprBooleanValue;
@@ -56,15 +53,14 @@
 import com.amazon.opendistroforelasticsearch.sql.data.model.ExprTupleValue;
 import com.amazon.opendistroforelasticsearch.sql.data.model.ExprValue;
 import com.amazon.opendistroforelasticsearch.sql.data.model.ExprValueUtils;
-import com.amazon.opendistroforelasticsearch.sql.exception.ExpressionEvaluationException;
 import com.amazon.opendistroforelasticsearch.sql.expression.DSL;
 import com.amazon.opendistroforelasticsearch.sql.expression.Expression;
 import com.amazon.opendistroforelasticsearch.sql.expression.ExpressionTestBase;
 import com.amazon.opendistroforelasticsearch.sql.expression.FunctionExpression;
-import com.amazon.opendistroforelasticsearch.sql.utils.OperatorUtils;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Lists;
+import com.sun.org.apache.xpath.internal.Arg;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.ObjectInputStream;
@@ -868,66 +864,4 @@ public void compare_int_long() {
     FunctionExpression equal = dsl.equal(DSL.literal(1), DSL.literal(1L));
     assertTrue(equal.valueOf(valueEnv()).booleanValue());
   }
-
-  private static Stream<Arguments> testInArguments() {
-    List<List> arguments =
-        Arrays.asList(Arrays.asList(1, Arrays.asList(0, 2, 1, 3)),
-            Arrays.asList(1, Arrays.asList(2, 0)), Arrays.asList(1L, Arrays.asList(1L, 2L, 3L)),
-            Arrays.asList(2L, Arrays.asList(1L, 2L)), Arrays.asList(3F, Arrays.asList(1F, 2F)),
-            Arrays.asList(0F, Arrays.asList(1F, 2F)), Arrays.asList(1D, Arrays.asList(1D, 1D)),
-            Arrays.asList(1D, Arrays.asList(2D, 2D)),
-            Arrays.asList("b", Arrays.asList("a", "c")),
-            Arrays.asList("b", Arrays.asList("c", "a")),
-            Arrays.asList("a", Arrays.asList("a", "b")),
-            Arrays.asList("b", Arrays.asList("a", "b")),
-            Arrays.asList("c", Arrays.asList("a", "b")),
-            Arrays.asList("a", Arrays.asList("b", "c")),
-            Arrays.asList("a", Arrays.asList("a", "a")),
-            Arrays.asList("b", Arrays.asList("a", "a")));
-
-    Stream.Builder<Arguments> builder = Stream.builder();
-    for (List<Object> argGroup : arguments) {
-      builder.add(Arguments.of(fromObjectValue(argGroup.get(0)), fromObjectValue(argGroup.get(1))));
-    }
-    builder
-        .add(Arguments.of(fromObjectValue("2021-01-02", DATE),
-            fromObjectValue(Arrays.asList(fromObjectValue("2021-01-01", DATE),
-                fromObjectValue("2021-01-03", DATE)))))
-        .add(Arguments.of(fromObjectValue("2021-01-02", DATE),
-            fromObjectValue(Arrays.asList(fromObjectValue("2021-01-01", DATE),
-                fromObjectValue("2021-01-03", DATE)))))
-        .add(Arguments.of(fromObjectValue("2021-01-01 03:00:00", DATETIME),
-            fromObjectValue(Arrays.asList(fromObjectValue("2021-01-01 01:00:00", DATETIME),
-                fromObjectValue("3021-01-01 02:00:00", DATETIME)))))
-        .add(Arguments.of(fromObjectValue("2021-01-01 01:00:00", TIMESTAMP),
-            fromObjectValue(Arrays.asList(fromObjectValue("2021-01-01 01:00:00", TIMESTAMP),
-            fromObjectValue("3021-01-01 01:00:00", TIMESTAMP)))));
-    return builder.build();
-  }
-
-  @ParameterizedTest(name = "in({0}, ({1}))")
-  @MethodSource("testInArguments")
-  public void in(ExprValue field, ExprValue arrayOfArgs) {
-    FunctionExpression in = dsl.in(
-        DSL.literal(field), DSL.literal(arrayOfArgs));
-    assertEquals(BOOLEAN, in.type());
-    assertEquals(OperatorUtils.in(field, arrayOfArgs), in.valueOf(valueEnv()));
-  }
-
-  @ParameterizedTest(name = "not in({0}, ({1}))")
-  @MethodSource("testInArguments")
-  public void not_in(ExprValue field, ExprValue arrayOfArgs) {
-    FunctionExpression notIn = dsl.not_in(
-        DSL.literal(field), DSL.literal(arrayOfArgs));
-    assertEquals(BOOLEAN, notIn.type());
-    assertEquals(!OperatorUtils.in(field, arrayOfArgs).booleanValue(),
-        notIn.valueOf(valueEnv()).booleanValue());
-  }
-
-  @Test
-  public void in_not_an_array() {
-    assertThrows(ExpressionEvaluationException.class, () ->
-        dsl.in(DSL.literal(1), DSL.literal("1")));
-  }
-
 }

elasticsearch/src/main/java/com/amazon/opendistroforelasticsearch/sql/elasticsearch/storage/script/filter/FilterQueryBuilder.java

@@ -24,7 +24,6 @@
 import com.amazon.opendistroforelasticsearch.sql.elasticsearch.storage.script.filter.lucene.RangeQuery;
 import com.amazon.opendistroforelasticsearch.sql.elasticsearch.storage.script.filter.lucene.RangeQuery.Comparison;
 import com.amazon.opendistroforelasticsearch.sql.elasticsearch.storage.script.filter.lucene.TermQuery;
-import com.amazon.opendistroforelasticsearch.sql.elasticsearch.storage.script.filter.lucene.TermsQuery;
 import com.amazon.opendistroforelasticsearch.sql.elasticsearch.storage.script.filter.lucene.WildcardQuery;
 import com.amazon.opendistroforelasticsearch.sql.elasticsearch.storage.serialization.ExpressionSerializer;
 import com.amazon.opendistroforelasticsearch.sql.expression.Expression;
@@ -64,7 +63,6 @@ public class FilterQueryBuilder extends ExpressionNodeVisitor<QueryBuilder, Obje
           .put(BuiltinFunctionName.LTE.getName(), new RangeQuery(Comparison.LTE))
           .put(BuiltinFunctionName.GTE.getName(), new RangeQuery(Comparison.GTE))
           .put(BuiltinFunctionName.LIKE.getName(), new WildcardQuery())
-          .put(BuiltinFunctionName.IN.getName(), new TermsQuery())
           .build();
 
   /**

elasticsearch/src/test/java/com/amazon/opendistroforelasticsearch/sql/elasticsearch/storage/script/filter/FilterQueryBuilderTest.java

@@ -16,7 +16,6 @@
 
 package com.amazon.opendistroforelasticsearch.sql.elasticsearch.storage.script.filter;
 
-import static com.amazon.opendistroforelasticsearch.sql.data.model.ExprValueUtils.fromObjectValue;
 import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.DATE;
 import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.DATETIME;
 import static com.amazon.opendistroforelasticsearch.sql.data.type.ExprCoreType.INTEGER;
@@ -149,43 +148,6 @@ void shouldBuildRangeQueryForDateComparisonExpressionAutocast(ExprType exprType,
             buildQuery(expr)));
   }
 
-  @Test
-  void should_build_terms_query_for_in_operator() {
-    assertJsonEquals(
-        "{\n"
-              + "  \"terms\" : {\n"
-              + "    \"age\" : [\n"
-              + "      30,\n"
-              + "      19\n"
-              + "    ],\n"
-              + "    \"boost\" : 1.0\n"
-              + "  }\n"
-              + "}",
-        buildQuery(dsl.in(ref("age", INTEGER),
-            literal(fromObjectValue(Arrays.asList(30, 19))))));
-
-    assertJsonEquals(
-        "{\n"
-            + "  \"bool\" : {\n"
-            + "    \"must_not\" : [\n"
-            + "      {\n"
-            + "        \"terms\" : {\n"
-            + "          \"age\" : [\n"
-            + "            30,\n"
-            + "            19\n"
-            + "          ],\n"
-            + "          \"boost\" : 1.0\n"
-            + "        }\n"
-            + "      }\n"
-            + "    ],\n"
-            + "    \"adjust_pure_negative\" : true,\n"
-            + "    \"boost\" : 1.0\n"
-            + "  }\n"
-            + "}",
-        buildQuery(dsl.not_in(ref("age", INTEGER),
-            literal(fromObjectValue(Arrays.asList(30,19))))));
-  }
-
   @Test
   void should_build_wildcard_query_for_like_expression() {
     assertJsonEquals(

integ-test/src/test/java/com/amazon/opendistroforelasticsearch/sql/legacy/CsvFormatResponseIT.java

@@ -395,9 +395,6 @@ public void aggAfterTermsGroupBy() throws Exception {
 
   @Test
   public void aggAfterTwoTermsGroupBy() throws Exception {
-    // disabling test for new engine because COUNT returns int in new engine,
-    // and float in the old engine
-    Assume.assumeFalse(isNewQueryEngineEabled());
     String query = String.format(Locale.ROOT,
         "SELECT COUNT(*) FROM %s where age in (35,36) GROUP BY gender,age",
         TEST_INDEX_ACCOUNT);
@@ -417,9 +414,6 @@ public void aggAfterTwoTermsGroupBy() throws Exception {
 
   @Test
   public void multipleAggAfterTwoTermsGroupBy() throws Exception {
-    // disabling test for new engine because COUNT returns int in new engine,
-    // and float in the old engine
-    Assume.assumeFalse(isNewQueryEngineEabled());
     String query = String.format(Locale.ROOT,
         "SELECT COUNT(*) , sum(balance) FROM %s where age in (35,36) GROUP BY gender,age",
         TEST_INDEX_ACCOUNT);

sql/src/main/antlr/OpenDistroSQLParser.g4

@@ -260,7 +260,6 @@ predicate
     | predicate IS nullNotnull                                      #isNullPredicate
     | left=predicate NOT? LIKE right=predicate                      #likePredicate
     | left=predicate REGEXP right=predicate                         #regexpPredicate
-    | predicate NOT? IN LR_BRACKET arrayArgs? RR_BRACKET                         #inPredicate
     ;
 
 expressionAtom
@@ -371,11 +370,3 @@ functionArg
     : expression
     ;
 
-arrayArgs
-    : arrayArg (COMMA arrayArg)*
-    ;
-
-arrayArg
-    : expression
-    ;
-

sql/src/main/java/com/amazon/opendistroforelasticsearch/sql/sql/parser/AstExpressionBuilder.java

@@ -18,11 +18,9 @@
 
 import static com.amazon.opendistroforelasticsearch.sql.ast.dsl.AstDSL.qualifiedName;
 import static com.amazon.opendistroforelasticsearch.sql.ast.dsl.AstDSL.stringLiteral;
-import static com.amazon.opendistroforelasticsearch.sql.expression.function.BuiltinFunctionName.IN;
 import static com.amazon.opendistroforelasticsearch.sql.expression.function.BuiltinFunctionName.IS_NOT_NULL;
 import static com.amazon.opendistroforelasticsearch.sql.expression.function.BuiltinFunctionName.IS_NULL;
 import static com.amazon.opendistroforelasticsearch.sql.expression.function.BuiltinFunctionName.LIKE;
-import static com.amazon.opendistroforelasticsearch.sql.expression.function.BuiltinFunctionName.NOT;
 import static com.amazon.opendistroforelasticsearch.sql.expression.function.BuiltinFunctionName.NOT_LIKE;
 import static com.amazon.opendistroforelasticsearch.sql.expression.function.BuiltinFunctionName.REGEXP;
 import static com.amazon.opendistroforelasticsearch.sql.sql.antlr.parser.OpenDistroSQLParser.BinaryComparisonPredicateContext;
@@ -63,10 +61,8 @@
 import com.amazon.opendistroforelasticsearch.sql.ast.expression.Case;
 import com.amazon.opendistroforelasticsearch.sql.ast.expression.Cast;
 import com.amazon.opendistroforelasticsearch.sql.ast.expression.Function;
-import com.amazon.opendistroforelasticsearch.sql.ast.expression.In;
 import com.amazon.opendistroforelasticsearch.sql.ast.expression.Interval;
 import com.amazon.opendistroforelasticsearch.sql.ast.expression.IntervalUnit;
-import com.amazon.opendistroforelasticsearch.sql.ast.expression.Literal;
 import com.amazon.opendistroforelasticsearch.sql.ast.expression.Not;
 import com.amazon.opendistroforelasticsearch.sql.ast.expression.Or;
 import com.amazon.opendistroforelasticsearch.sql.ast.expression.QualifiedName;
@@ -237,19 +233,6 @@ public UnresolvedExpression visitRegexpPredicate(RegexpPredicateContext ctx) {
             Arrays.asList(visit(ctx.left), visit(ctx.right)));
   }
 
-  @Override
-  public UnresolvedExpression visitInPredicate(OpenDistroSQLParser.InPredicateContext ctx) {
-    UnresolvedExpression between = new Function(IN.getName().getFunctionName(),
-        Arrays.asList(visit(ctx.predicate()), AstDSL.arrayLiteral(ctx.arrayArgs().arrayArg()
-            .stream()
-            .map(this::visitArrayArg)
-            .map(unresolvedExpression -> ((Literal) unresolvedExpression).getValue())
-            .collect(Collectors.toList()))));
-
-    return ctx.NOT() == null ? between :
-        new Function(NOT.getName().getFunctionName(), Collections.singletonList(between));
-  }
-
   @Override
   public UnresolvedExpression visitAndExpression(AndExpressionContext ctx) {
     return new And(visit(ctx.left), visit(ctx.right));

sql/src/test/java/com/amazon/opendistroforelasticsearch/sql/sql/antlr/SQLSyntaxParserTest.java

@@ -131,13 +131,6 @@ public void canParseCaseStatement() {
     assertNotNull(parser.parse("SELECT CASE age WHEN 30 THEN 'age1' END FROM test"));
   }
 
-  @Test
-  public void canParseInStatement() {
-    assertNotNull(parser.parse("SELECT age FROM test WHERE age IN (1,30)"));
-    assertNotNull(parser.parse("SELECT age FROM test WHERE age NOT IN (1,30)"));
-    assertNotNull(parser.parse("SELECT age FROM test WHERE NOT (age IN (1,30))"));
-  }
-
   @Test
   public void canNotParseAggregateFunctionWithWrongArgument() {
     assertThrows(SyntaxCheckException.class, () -> parser.parse("SELECT SUM() FROM test"));

sql/src/test/java/com/amazon/opendistroforelasticsearch/sql/sql/parser/AstExpressionBuilderTest.java

@@ -18,13 +18,11 @@
 
 import static com.amazon.opendistroforelasticsearch.sql.ast.dsl.AstDSL.aggregate;
 import static com.amazon.opendistroforelasticsearch.sql.ast.dsl.AstDSL.and;
-import static com.amazon.opendistroforelasticsearch.sql.ast.dsl.AstDSL.arrayLiteral;
 import static com.amazon.opendistroforelasticsearch.sql.ast.dsl.AstDSL.booleanLiteral;
 import static com.amazon.opendistroforelasticsearch.sql.ast.dsl.AstDSL.caseWhen;
 import static com.amazon.opendistroforelasticsearch.sql.ast.dsl.AstDSL.dateLiteral;
 import static com.amazon.opendistroforelasticsearch.sql.ast.dsl.AstDSL.doubleLiteral;
 import static com.amazon.opendistroforelasticsearch.sql.ast.dsl.AstDSL.function;
-import static com.amazon.opendistroforelasticsearch.sql.ast.dsl.AstDSL.in;
 import static com.amazon.opendistroforelasticsearch.sql.ast.dsl.AstDSL.intLiteral;
 import static com.amazon.opendistroforelasticsearch.sql.ast.dsl.AstDSL.intervalLiteral;
 import static com.amazon.opendistroforelasticsearch.sql.ast.dsl.AstDSL.longLiteral;
@@ -51,7 +49,6 @@
 import com.amazon.opendistroforelasticsearch.sql.sql.antlr.parser.OpenDistroSQLLexer;
 import com.amazon.opendistroforelasticsearch.sql.sql.antlr.parser.OpenDistroSQLParser;
 import com.google.common.collect.ImmutableList;
-import java.util.Arrays;
 import org.antlr.v4.runtime.CommonTokenStream;
 import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.junit.jupiter.api.Test;
@@ -286,20 +283,6 @@ public void canBuildLogicalExpression() {
     );
   }
 
-  @Test
-  public void canBuildInPredicate() {
-    assertEquals(function("in", intLiteral(1), arrayLiteral(Arrays.asList(0,2,3,4))),
-        buildExprAst("1 in (0,2,3,4)"));
-  }
-
-  @Test
-  public void canBuildNotInPredicate() {
-    assertEquals(
-        function("not",
-            function("in", intLiteral(1),arrayLiteral(Arrays.asList(0,2,3,4)))),
-        buildExprAst("1 not in (0,2,3,4)"));
-  }
-
   @Test
   public void canBuildWindowFunction() {
     assertEquals(