Legacy fall back with JSON format

core/src/main/java/org/opensearch/sql/analysis/JsonSupportVisitor.java

@@ -0,0 +1,119 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.analysis;
+
+import org.apache.commons.lang3.StringUtils;
+import org.opensearch.sql.ast.AbstractNodeVisitor;
+import org.opensearch.sql.ast.Node;
+import org.opensearch.sql.ast.expression.Alias;
+import org.opensearch.sql.ast.expression.Cast;
+import org.opensearch.sql.ast.expression.Function;
+import org.opensearch.sql.ast.expression.Literal;
+import org.opensearch.sql.ast.tree.Aggregation;
+import org.opensearch.sql.ast.tree.Project;
+
+/**
+ * This visitor's sole purpose is to throw UnsupportedOperationExceptions
+ * for unsupported features in the new engine when JSON format is specified.
+ * Unsupported features in V2 are ones the produce results that differ from
+ * legacy results.
+ */
+public class JsonSupportVisitor extends AbstractNodeVisitor<Boolean, JsonSupportVisitorContext> {
+  @Override
+  public Boolean visit(Node node, JsonSupportVisitorContext context) {
+    return visitChildren(node, context);
+  }
+
+  @Override
+  public Boolean visitChildren(Node node, JsonSupportVisitorContext context) {
+    for (Node child : node.getChild()) {
+      if (!child.accept(this, context)) {
+        return Boolean.FALSE;
+      }
+    }
+    return Boolean.TRUE;
+  }
+
+  @Override
+  public Boolean visitAggregation(Aggregation node, JsonSupportVisitorContext context) {
+    if (node.getGroupExprList().isEmpty()) {
+      return Boolean.TRUE;
+    } else {
+      context.setUnsupportedOperationException(new UnsupportedOperationException(
+          "Queries with aggregation are not yet supported with json format in the new engine"));
+      return Boolean.FALSE;
+    }
+  }
+
+  @Override
+  public Boolean visitFunction(Function node, JsonSupportVisitorContext context) {
+    // Supported if outside of Project
+    if (!context.isVisitingProject()) {
+      return Boolean.TRUE;
+    }
+
+    // queries with function calls are not supported.
+    context.setUnsupportedOperationException(new UnsupportedOperationException(
+        "Queries with functions are not yet supported with json format in the new engine"));
+    return Boolean.FALSE;
+  }
+
+  @Override
+  public Boolean visitLiteral(Literal node, JsonSupportVisitorContext context) {
+    // Supported if outside of Project
+    if (!context.isVisitingProject()) {
+      return Boolean.TRUE;
+    }
+
+    // queries with literal values are not supported
+    context.setUnsupportedOperationException(new UnsupportedOperationException(
+        "Queries with literals are not yet supported with json format in the new engine"));
+    return Boolean.FALSE;
+  }
+
+  @Override
+  public Boolean visitCast(Cast node, JsonSupportVisitorContext context) {
+    // Supported if outside of Project
+    if (!context.isVisitingProject()) {
+      return Boolean.TRUE;
+    }
+
+    // Queries with cast are not supported
+    context.setUnsupportedOperationException(new UnsupportedOperationException(
+        "Queries with casts are not yet supported with json format in the new engine"));
+    return Boolean.FALSE;
+  }
+
+  @Override
+  public Boolean visitAlias(Alias node, JsonSupportVisitorContext context) {
+    // Supported if outside of Project
+    if (!context.isVisitingProject()) {
+      return Boolean.TRUE;
+    }
+
+    // Alias node is accepted if it does not have a user-defined alias
+    // and if the delegated expression is accepted.
+    if (StringUtils.isEmpty(node.getAlias())) {
+      return node.getDelegated().accept(this, context);
+    } else {
+      context.setUnsupportedOperationException(new UnsupportedOperationException(
+          "Queries with aliases are not yet supported with json format in the new engine"));
+      return Boolean.FALSE;
+    }
+  }
+
+  @Override
+  public Boolean visitProject(Project node, JsonSupportVisitorContext context) {
+    boolean isSupported = visit(node, context);
+
+    context.setVisitingProject(true);
+    isSupported = isSupported ? node.getProjectList().stream()
+        .allMatch(e -> e.accept(this, context)) : Boolean.FALSE;
+    context.setVisitingProject(false);
+
+    return isSupported;
+  }
+}

core/src/main/java/org/opensearch/sql/analysis/JsonSupportVisitorContext.java

@@ -0,0 +1,22 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.analysis;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * The context used for JsonSupportVisitor.
+ */
+public class JsonSupportVisitorContext {
+  @Getter
+  @Setter
+  private boolean isVisitingProject = false;
+
+  @Getter
+  @Setter
+  private UnsupportedOperationException unsupportedOperationException;
+}

core/src/test/java/org/opensearch/sql/analysis/JsonSupportVisitorTest.java

@@ -0,0 +1,111 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.analysis;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.opensearch.sql.ast.dsl.AstDSL.qualifiedName;
+
+import com.google.common.collect.ImmutableList;
+import java.util.Collections;
+import org.junit.jupiter.api.Test;
+import org.opensearch.sql.ast.dsl.AstDSL;
+import org.opensearch.sql.ast.expression.Literal;
+import org.opensearch.sql.ast.expression.UnresolvedExpression;
+import org.opensearch.sql.ast.tree.UnresolvedPlan;
+
+class JsonSupportVisitorTest {
+  @Test
+  public void visitLiteralInProject() {
+    UnresolvedPlan project = AstDSL.project(
+        AstDSL.relation("table", "table"),
+        AstDSL.intLiteral(1));
+    assertFalse(project.accept(new JsonSupportVisitor(), new JsonSupportVisitorContext()));
+  }
+
+  @Test
+  public void visitLiteralOutsideProject() {
+    Literal intLiteral = AstDSL.intLiteral(1);
+    assertTrue(intLiteral.accept(new JsonSupportVisitor(), new JsonSupportVisitorContext()));
+  }
+
+  @Test
+  public void visitCastInProject() {
+    UnresolvedPlan project = AstDSL.project(
+        AstDSL.relation("table", "table"),
+        AstDSL.cast(AstDSL.intLiteral(1), AstDSL.stringLiteral("INT")));
+    assertFalse(project.accept(new JsonSupportVisitor(), new JsonSupportVisitorContext()));
+  }
+
+  @Test
+  public void visitCastOutsideProject() {
+    UnresolvedExpression intCast = AstDSL.cast(
+        AstDSL.intLiteral(1),
+        AstDSL.stringLiteral("INT"));
+    assertTrue(intCast.accept(new JsonSupportVisitor(), new JsonSupportVisitorContext()));
+  }
+
+  @Test
+  public void visitAliasInProject() {
+    UnresolvedPlan project = AstDSL.project(
+        AstDSL.relation("table", "table"),
+        AstDSL.alias("alias", AstDSL.intLiteral(1)));
+    assertFalse(project.accept(new JsonSupportVisitor(), new JsonSupportVisitorContext()));
+  }
+
+  @Test
+  public void visitAliasInProjectWithDelegated() {
+    UnresolvedPlan project = AstDSL.project(
+        AstDSL.relation("table", "table"),
+        AstDSL.alias("alias", AstDSL.intLiteral(1), "alias"));
+    assertFalse(project.accept(new JsonSupportVisitor(), new JsonSupportVisitorContext()));
+  }
+
+  @Test
+  public void visitAliasOutsideProject() {
+    UnresolvedExpression alias = AstDSL.alias("alias", AstDSL.intLiteral(1));
+    assertTrue(alias.accept(new JsonSupportVisitor(), new JsonSupportVisitorContext()));
+  }
+
+  @Test
+  public void visitFunctionInProject() {
+    UnresolvedPlan function = AstDSL.project(
+        AstDSL.relation("table", "table"),
+        AstDSL.function("abs", AstDSL.intLiteral(-1)));
+    assertFalse(function.accept(new JsonSupportVisitor(), new JsonSupportVisitorContext()));
+  }
+
+  @Test
+  public void visitFunctionOutsideProject() {
+    UnresolvedExpression function = AstDSL.function("abs", AstDSL.intLiteral(-1));
+    assertTrue(function.accept(new JsonSupportVisitor(), new JsonSupportVisitorContext()));
+  }
+
+  @Test
+  public void visitAggregationWithGroupExprList() {
+    UnresolvedPlan projectAggr = AstDSL.project(AstDSL.agg(
+        AstDSL.relation("table", "table"),
+        Collections.emptyList(),
+        Collections.emptyList(),
+        ImmutableList.of(AstDSL.alias("alias", qualifiedName("integer_value"))),
+        Collections.emptyList()));
+    assertFalse(projectAggr.accept(new JsonSupportVisitor(), new JsonSupportVisitorContext()));
+  }
+
+  @Test
+  public void visitAggregationWithAggExprList() {
+    UnresolvedPlan aggregation = AstDSL.agg(
+        AstDSL.relation("table", "table"),
+        ImmutableList.of(
+            AstDSL.alias("AVG(alias)",
+                AstDSL.aggregate("AVG",
+                    qualifiedName("integer_value")))),
+        Collections.emptyList(),
+        Collections.emptyList(),
+        Collections.emptyList());
+    assertTrue(aggregation.accept(new JsonSupportVisitor(), new JsonSupportVisitorContext()));
+  }
+}

integ-test/src/test/java/org/opensearch/sql/legacy/DateFormatIT.java

@@ -28,6 +28,7 @@
 import org.json.JSONObject;
 import org.junit.Ignore;
 import org.junit.Test;
+import org.opensearch.client.ResponseException;
 import org.opensearch.sql.legacy.exception.SqlParseException;
 
 public class DateFormatIT extends SQLIntegTestCase {
@@ -50,7 +51,8 @@ protected void init() throws Exception {
    * this ends up excluding some of the expected values causing the assertion to fail. LIMIT overrides this.
    */
 
-  @Test
+  // DATE_FORMAT with timezone argument is not yet supported in V2
+  @Test(expected = SqlParseException.class)
   public void equalTo() throws SqlParseException {
     assertThat(
         dateQuery(
@@ -59,7 +61,8 @@ public void equalTo() throws SqlParseException {
     );
   }
 
-  @Test
+  // DATE_FORMAT with timezone argument is not yet supported in V2
+  @Test(expected = SqlParseException.class)
   public void lessThan() throws SqlParseException {
     assertThat(
         dateQuery(
@@ -68,7 +71,8 @@ public void lessThan() throws SqlParseException {
     );
   }
 
-  @Test
+  // DATE_FORMAT with timezone argument is not yet supported in V2
+  @Test(expected = SqlParseException.class)
   public void lessThanOrEqualTo() throws SqlParseException {
     assertThat(
         dateQuery(
@@ -79,7 +83,8 @@ public void lessThanOrEqualTo() throws SqlParseException {
     );
   }
 
-  @Test
+  // DATE_FORMAT with timezone argument is not yet supported in V2
+  @Test(expected = SqlParseException.class)
   public void greaterThan() throws SqlParseException {
     assertThat(
         dateQuery(
@@ -88,7 +93,8 @@ public void greaterThan() throws SqlParseException {
     );
   }
 
-  @Test
+  // DATE_FORMAT with timezone argument is not yet supported in V2
+  @Test(expected = SqlParseException.class)
   public void greaterThanOrEqualTo() throws SqlParseException {
     assertThat(
         dateQuery(
@@ -99,7 +105,8 @@ public void greaterThanOrEqualTo() throws SqlParseException {
     );
   }
 
-  @Test
+  // DATE_FORMAT with timezone argument is not yet supported in V2
+  @Test(expected = SqlParseException.class)
   public void and() throws SqlParseException {
     assertThat(
         dateQuery(SELECT_FROM +
@@ -122,7 +129,8 @@ public void andWithDefaultTimeZone() throws SqlParseException {
     );
   }
 
-  @Test
+  // DATE_FORMAT with timezone argument is not yet supported in V2
+  @Test(expected = SqlParseException.class)
   public void or() throws SqlParseException {
     assertThat(
         dateQuery(SELECT_FROM +
@@ -134,8 +142,8 @@ public void or() throws SqlParseException {
     );
   }
 
-
-  @Test
+  // DATE_FORMAT with timezone argument is not yet supported in V2
+  @Test(expected = ResponseException.class)
   public void sortByDateFormat() throws IOException {
     // Sort by expression in descending order, but sort inside in ascending order, so we increase our confidence
     // that successful test isn't just random chance.

integ-test/src/test/java/org/opensearch/sql/legacy/QueryFunctionsIT.java

@@ -28,6 +28,7 @@
 import org.json.JSONObject;
 import org.junit.Test;
 import org.opensearch.action.search.SearchResponse;
+import org.opensearch.client.ResponseException;
 import org.opensearch.common.xcontent.LoggingDeprecationHandler;
 import org.opensearch.common.xcontent.XContentFactory;
 import org.opensearch.common.xcontent.XContentType;
@@ -133,7 +134,9 @@ public void scoreQueryWithNestedField() throws IOException {
     );
   }
 
-  @Test
+  // Specifying city.keyword is not supported in V2
+  // Rework on data types is in progress and tracked with https://github.com/opensearch-project/sql/pull/1314
+  @Test(expected = ResponseException.class)
   public void wildcardQuery() throws IOException {
     assertThat(
         query(