Legacy fall back with JSON format

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

@@ -0,0 +1,80 @@
+/*
+ * 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.Filter;
+import org.opensearch.sql.ast.tree.Project;
+
+public class JsonSupportAnalyzer extends AbstractNodeVisitor<Boolean, Object> {
+  @Override
+  public Boolean visit(Node node, Object context) {
+    // A node is supported if all of its children are supported.
+    return node.getChild().stream().allMatch(c -> c.accept(this, null));
+  }
+
+  @Override
+  public Boolean visitChildren(Node node, Object context) {
+    for (Node child : node.getChild()) {
+      if (!child.accept(this, null))
+        return false;
+    }
+    return true;
+  }
+
+  @Override
+  public Boolean visitFunction(Function node, Object context) {
+    // queries with function calls are not supported.
+    return false;
+  }
+
+  @Override
+  public Boolean visitLiteral(Literal node, Object context) {
+    // queries with literal values are not supported
+    return false;
+  }
+
+  @Override
+  public Boolean visitCast(Cast node, Object context) {
+    // Queries with cast are not supported
+    return false;
+  }
+
+  @Override
+  public Boolean visitAlias(Alias node, Object context) {
+    // 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 false;
+    else {
+      return node.getDelegated().accept(this, null);
+    }
+  }
+
+  @Override
+  public Boolean visitProject(Project node, Object context) {
+    return visit(node, null)
+        && node.getProjectList().stream().allMatch(e -> e.accept(this, null));
+  }
+
+  @Override
+  public Boolean visitAggregation(Aggregation node, Object context) {
+    return node.getGroupExprList().isEmpty();
+  }
+
+  @Override
+  public Boolean visitFilter(Filter node, Object context) {
+    return visit(node, null)
+        && node.getCondition().accept(this, null);
+  }
+}

legacy/src/main/java/org/opensearch/sql/legacy/plugin/RestSQLQueryAction.java

@@ -126,7 +126,7 @@ public void onResponse(T response) {
 
       @Override
       public void onFailure(Exception e) {
-        if (e instanceof SyntaxCheckException) {
+        if (e instanceof SyntaxCheckException || e instanceof UnsupportedOperationException) {
           fallBackHandler.accept(channel, e);
         } else {
           next.onFailure(e);

sql/src/main/java/org/opensearch/sql/sql/SQLService.java

@@ -7,8 +7,11 @@
 package org.opensearch.sql.sql;
 
 import java.util.Optional;
+
 import lombok.RequiredArgsConstructor;
 import org.antlr.v4.runtime.tree.ParseTree;
+import org.opensearch.sql.analysis.JsonSupportAnalyzer;
+import org.opensearch.sql.ast.statement.Query;
 import org.opensearch.sql.ast.statement.Statement;
 import org.opensearch.sql.common.response.ResponseListener;
 import org.opensearch.sql.executor.ExecutionEngine.ExplainResponse;
@@ -65,6 +68,9 @@ private AbstractPlan plan(
       SQLQueryRequest request,
       Optional<ResponseListener<QueryResponse>> queryListener,
       Optional<ResponseListener<ExplainResponse>> explainListener) {
+    if (parser.containsHints(request.getQuery()))
+      throw new UnsupportedOperationException("Hints are not yet supported in the new engine.");
+
     // 1.Parse query and convert parse tree (CST) to abstract syntax tree (AST)
     ParseTree cst = parser.parse(request.getQuery());
     Statement statement =
@@ -75,6 +81,18 @@ private AbstractPlan plan(
                     .isExplain(request.isExplainRequest())
                     .build()));
 
+    // There is no full support for JSON format yet for in memory operations, aliases, literals, and casts
+    // Aggregation has differences with legacy results
+    if (request.format().getFormatName().equals("json") && statement instanceof Query) {
+      Boolean isJsonSupported = ((Query) statement).getPlan().accept(new JsonSupportAnalyzer(), null);
+
+      if (!isJsonSupported) {
+        throw new UnsupportedOperationException(
+            "Queries with aggregation and in memory operations (cast, literals, alias, math, etc.)"
+                + " are not yet supported with json format in the new engine");
+      }
+    }
+
     return queryExecutionFactory.create(statement, queryListener, explainListener);
   }
 }

sql/src/main/java/org/opensearch/sql/sql/antlr/SQLSyntaxParser.java

@@ -32,4 +32,9 @@ public ParseTree parse(String query) {
     return parser.root();
   }
 
+  public boolean containsHints(String query) {
+    OpenSearchSQLLexer lexer = new OpenSearchSQLLexer(new CaseInsensitiveCharStream(query));
+    OpenSearchSQLParser hintsParser = new OpenSearchSQLParser(new CommonTokenStream(lexer, OpenSearchSQLLexer.SQLCOMMENT));
+    return hintsParser.root().getChildCount() > 1;
+  }
 }

sql/src/test/java/org/opensearch/sql/sql/SQLServiceTest.java

@@ -7,6 +7,7 @@
 package org.opensearch.sql.sql;
 
 import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doAnswer;
@@ -83,6 +84,114 @@ public void onFailure(Exception e) {
         });
   }
 
+  @Test
+  public void canExecuteJsonFormatRequest() {
+    doAnswer(invocation -> {
+      ResponseListener<QueryResponse> listener = invocation.getArgument(1);
+      listener.onResponse(new QueryResponse(schema, Collections.emptyList(), ""));
+      return null;
+    }).when(queryService).execute(any(), any());
+
+    sqlService.execute(
+        new SQLQueryRequest(new JSONObject(), "SELECT FIELD FROM TABLE", QUERY, "json"),
+        new ResponseListener<QueryResponse>() {
+          @Override
+          public void onResponse(QueryResponse response) {
+            assertNotNull(response);
+          }
+
+          @Override
+          public void onFailure(Exception e) {
+            fail(e);
+          }
+        });
+  }
+
+  @Test
+  public void canThrowUnsupportedExceptionForAggregationJsonQuery() {
+    sqlService.execute(
+        new SQLQueryRequest(new JSONObject(), "SELECT FIELD FROM TABLE GROUP BY FIELD", QUERY, "json"),
+        new ResponseListener<QueryResponse>() {
+          @Override
+          public void onResponse(QueryResponse response) {
+            assertNotNull(response);
+          }
+
+          @Override
+          public void onFailure(Exception e) {
+            assertTrue(e instanceof UnsupportedOperationException);
+          }
+        });
+  }
+
+  @Test
+  public void canThrowUnsupportedExceptionForAliasJsonQuery() {
+    sqlService.execute(
+        new SQLQueryRequest(new JSONObject(), "SELECT FIELD as FIELD FROM TABLE", QUERY, "json"),
+        new ResponseListener<QueryResponse>() {
+          @Override
+          public void onResponse(QueryResponse response) {
+            assertNotNull(response);
+          }
+
+          @Override
+          public void onFailure(Exception e) {
+            assertTrue(e instanceof UnsupportedOperationException);
+          }
+        });
+  }
+
+  @Test
+  public void canThrowUnsupportedExceptionForFunctionJsonQuery() {
+    sqlService.execute(
+        new SQLQueryRequest(new JSONObject(), "SELECT 1 + 1", QUERY, "json"),
+        new ResponseListener<QueryResponse>() {
+          @Override
+          public void onResponse(QueryResponse response) {
+            assertNotNull(response);
+          }
+
+          @Override
+          public void onFailure(Exception e) {
+            assertTrue(e instanceof UnsupportedOperationException);
+          }
+        });
+  }
+
+  @Test
+  public void canThrowUnsupportedExceptionForLiteralJsonQuery() {
+    sqlService.execute(
+        new SQLQueryRequest(new JSONObject(), "SELECT 123", QUERY, "json"),
+        new ResponseListener<QueryResponse>() {
+          @Override
+          public void onResponse(QueryResponse response) {
+            assertNotNull(response);
+          }
+
+          @Override
+          public void onFailure(Exception e) {
+            assert(e instanceof UnsupportedOperationException);
+          }
+        });
+  }
+
+  @Test
+  public void canThrowUnsupportedExceptionForCastJsonQuery() {
+    sqlService.execute(
+        new SQLQueryRequest(new JSONObject(), "SELECT CAST(FIELD AS DOUBLE)", QUERY, "json"),
+        new ResponseListener<QueryResponse>() {
+          @Override
+          public void onResponse(QueryResponse response) {
+            assertNotNull(response);
+          }
+
+          @Override
+          public void onFailure(Exception e) {
+            assert(e instanceof UnsupportedOperationException);
+          }
+        });
+  }
+
   @Test
   public void canExecuteCsvFormatRequest() {
     doAnswer(invocation -> {
@@ -106,6 +215,23 @@ public void onFailure(Exception e) {
         });
   }
 
+  @Test
+  public void canThrowUnsupportedExceptionForHintsQuery() {
+    sqlService.execute(
+        new SQLQueryRequest(new JSONObject(), "SELECT /*! HINTS */ 123", QUERY, "jdbc"),
+        new ResponseListener<QueryResponse>() {
+          @Override
+          public void onResponse(QueryResponse response) {
+            assertNotNull(response);
+          }
+
+          @Override
+          public void onFailure(Exception e) {
+            assert(e instanceof UnsupportedOperationException);
+          }
+        });
+  }
+
   @Test
   public void canExplainSqlQuery() {
     doAnswer(invocation -> {