New added commands should throw exception when calcite disabled

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

@@ -10,6 +10,7 @@
 import static org.opensearch.sql.ast.tree.Sort.NullOrder.NULL_LAST;
 import static org.opensearch.sql.ast.tree.Sort.SortOrder.ASC;
 import static org.opensearch.sql.ast.tree.Sort.SortOrder.DESC;
+import static org.opensearch.sql.common.setting.Settings.Key.CALCITE_ENGINE_ENABLED;
 import static org.opensearch.sql.data.type.ExprCoreType.DATE;
 import static org.opensearch.sql.data.type.ExprCoreType.STRUCT;
 import static org.opensearch.sql.data.type.ExprCoreType.TIME;
@@ -53,8 +54,10 @@
 import org.opensearch.sql.ast.tree.FillNull;
 import org.opensearch.sql.ast.tree.Filter;
 import org.opensearch.sql.ast.tree.Head;
+import org.opensearch.sql.ast.tree.Join;
 import org.opensearch.sql.ast.tree.Kmeans;
 import org.opensearch.sql.ast.tree.Limit;
+import org.opensearch.sql.ast.tree.Lookup;
 import org.opensearch.sql.ast.tree.ML;
 import org.opensearch.sql.ast.tree.Paginate;
 import org.opensearch.sql.ast.tree.Parse;
@@ -162,8 +165,8 @@ public LogicalPlan visitSubqueryAlias(SubqueryAlias node, AnalysisContext contex
           STRUCT);
       return child;
     } else {
-      // TODO
-      throw new UnsupportedOperationException("SubqueryAlias is only supported in table alias");
+      throw new UnsupportedOperationException(
+          "Subsearch is supported only when " + CALCITE_ENGINE_ENABLED.getKeyValue() + "=true");
     }
   }
 
@@ -685,6 +688,18 @@ public LogicalPlan visitCloseCursor(CloseCursor closeCursor, AnalysisContext con
     return new LogicalCloseCursor(closeCursor.getChild().get(0).accept(this, context));
   }
 
+  @Override
+  public LogicalPlan visitJoin(Join node, AnalysisContext context) {
+    throw new UnsupportedOperationException(
+        "Join is supported only when " + CALCITE_ENGINE_ENABLED.getKeyValue() + "=true");
+  }
+
+  @Override
+  public LogicalPlan visitLookup(Lookup node, AnalysisContext context) {
+    throw new UnsupportedOperationException(
+        "Lookup is supported only when " + CALCITE_ENGINE_ENABLED.getKeyValue() + "=true");
+  }
+
   private LogicalSort buildSort(
       LogicalPlan child, AnalysisContext context, List<Field> sortFields) {
     ExpressionReferenceOptimizer optimizer =

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

@@ -7,6 +7,7 @@
 
 import static org.opensearch.sql.ast.dsl.AstDSL.and;
 import static org.opensearch.sql.ast.dsl.AstDSL.compare;
+import static org.opensearch.sql.common.setting.Settings.Key.CALCITE_ENGINE_ENABLED;
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
@@ -49,6 +50,9 @@
 import org.opensearch.sql.ast.expression.When;
 import org.opensearch.sql.ast.expression.WindowFunction;
 import org.opensearch.sql.ast.expression.Xor;
+import org.opensearch.sql.ast.expression.subquery.ExistsSubquery;
+import org.opensearch.sql.ast.expression.subquery.InSubquery;
+import org.opensearch.sql.ast.expression.subquery.ScalarSubquery;
 import org.opensearch.sql.data.model.ExprValueUtils;
 import org.opensearch.sql.data.type.ExprCoreType;
 import org.opensearch.sql.data.type.ExprType;
@@ -406,6 +410,24 @@ public Expression visitArgument(Argument node, AnalysisContext context) {
     return new NamedArgumentExpression(node.getArgName(), node.getValue().accept(this, context));
   }
 
+  @Override
+  public Expression visitScalarSubquery(ScalarSubquery node, AnalysisContext context) {
+    throw new UnsupportedOperationException(
+        "Subsearch is supported only when " + CALCITE_ENGINE_ENABLED.getKeyValue() + "=true");
+  }
+
+  @Override
+  public Expression visitExistsSubquery(ExistsSubquery node, AnalysisContext context) {
+    throw new UnsupportedOperationException(
+        "Subsearch is supported only when " + CALCITE_ENGINE_ENABLED.getKeyValue() + "=true");
+  }
+
+  @Override
+  public Expression visitInSubquery(InSubquery node, AnalysisContext context) {
+    throw new UnsupportedOperationException(
+        "Subsearch is supported only when " + CALCITE_ENGINE_ENABLED.getKeyValue() + "=true");
+  }
+
   /**
    * If QualifiedName is actually a reserved metadata field, return the expr type associated with
    * the metadata field.

integ-test/src/test/java/org/opensearch/sql/calcite/remote/CalciteNewAddedCommandsIT.java

@@ -0,0 +1,17 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.calcite.remote;
+
+import org.opensearch.sql.ppl.NewAddedCommandsIT;
+
+public class CalciteNewAddedCommandsIT extends NewAddedCommandsIT {
+  @Override
+  public void init() throws Exception {
+    super.init();
+    enableCalcite();
+    disallowCalciteFallback();
+  }
+}

integ-test/src/test/java/org/opensearch/sql/ppl/NewAddedCommandsIT.java

@@ -0,0 +1,136 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.ppl;
+
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.equalTo;
+import static org.opensearch.sql.common.setting.Settings.Key.CALCITE_ENGINE_ENABLED;
+import static org.opensearch.sql.legacy.TestsConstants.TEST_INDEX_BANK;
+import static org.opensearch.sql.legacy.TestsConstants.TEST_INDEX_DOG;
+
+import java.io.IOException;
+import org.json.JSONObject;
+import org.junit.jupiter.api.Test;
+import org.opensearch.client.ResponseException;
+import org.opensearch.sql.util.TestUtils;
+
+public class NewAddedCommandsIT extends PPLIntegTestCase {
+  @Override
+  public void init() throws Exception {
+    super.init();
+    loadIndex(Index.BANK);
+    loadIndex(Index.DOG);
+  }
+
+  @Test
+  public void testJoin() {
+    try {
+      JSONObject result;
+      try {
+        result =
+            executeQuery(
+                String.format(
+                    "search source=%s | join on firstname=holdersName %s",
+                    TEST_INDEX_BANK, TEST_INDEX_DOG));
+      } catch (ResponseException e) {
+        result = new JSONObject(TestUtils.getResponseBody(e.getResponse()));
+        verifyQuery(result);
+      }
+    } catch (IOException e) {
+      fail(e.getMessage());
+    }
+  }
+
+  @Test
+  public void testLookup() {
+    try {
+      JSONObject result;
+      try {
+        result =
+            executeQuery(
+                String.format(
+                    "search source=%s | lookup %s holdersName as firstname",
+                    TEST_INDEX_BANK, TEST_INDEX_DOG));
+      } catch (ResponseException e) {
+        result = new JSONObject(TestUtils.getResponseBody(e.getResponse()));
+      }
+      verifyQuery(result);
+    } catch (IOException e) {
+      fail(e.getMessage());
+    }
+  }
+
+  @Test
+  public void testSubsearch() {
+    try {
+      JSONObject result;
+      try {
+        result =
+            executeQuery(
+                String.format(
+                    "search source=[source=%s | where age>35] as t | where age>35",
+                    TEST_INDEX_BANK));
+      } catch (ResponseException e) {
+        result = new JSONObject(TestUtils.getResponseBody(e.getResponse()));
+      }
+      verifyQuery(result);
+
+      try {
+        result =
+            executeQuery(
+                String.format(
+                    "search source=%s | where exists [ source=%s | where firstname=holdersName]",
+                    TEST_INDEX_BANK, TEST_INDEX_DOG));
+      } catch (ResponseException e) {
+        result = new JSONObject(TestUtils.getResponseBody(e.getResponse()));
+      }
+      verifyQuery(result);
+
+      try {
+        result =
+            executeQuery(
+                String.format(
+                    "search source=%s | where firstname in [ source=%s | fields holdersName]",
+                    TEST_INDEX_BANK, TEST_INDEX_DOG));
+      } catch (ResponseException e) {
+        result = new JSONObject(TestUtils.getResponseBody(e.getResponse()));
+      }
+      verifyQuery(result);
+
+      try {
+        result =
+            executeQuery(
+                String.format(
+                    "search source=%s | where firstname = [ source=%s | where holdersName='Hattie'"
+                        + " | fields holdersName | head 1]",
+                    TEST_INDEX_BANK, TEST_INDEX_DOG));
+      } catch (ResponseException e) {
+        result = new JSONObject(TestUtils.getResponseBody(e.getResponse()));
+      }
+      verifyQuery(result);
+    } catch (IOException e) {
+      fail(e.getMessage());
+    }
+  }
+
+  private void verifyQuery(JSONObject result) {
+    try {
+      if (isCalciteEnabled()) {
+        assertFalse(result.getJSONArray("datarows").isEmpty());
+      } else {
+        assertThat(result.getInt("status"), equalTo(500));
+        JSONObject error = result.getJSONObject("error");
+        assertThat(
+            error.getString("details"),
+            containsString(
+                "is supported only when " + CALCITE_ENGINE_ENABLED.getKeyValue() + "=true"));
+        assertThat(error.getString("type"), equalTo("UnsupportedOperationException"));
+      }
+    } catch (IOException e) {
+      fail(e.getMessage());
+    }
+  }
+}

integ-test/src/test/java/org/opensearch/sql/ppl/PPLIntegTestCase.java

@@ -147,27 +147,39 @@ public static void disallowCalciteFallback() throws IOException {
     LOG.info("{} disabled", Settings.Key.CALCITE_FALLBACK_ALLOWED.name());
   }
 
-  protected static boolean isFallbackEnabled() throws IOException {
-    return Boolean.parseBoolean(
-        getClusterSetting(Settings.Key.CALCITE_FALLBACK_ALLOWED.getKeyValue(), "persistent"));
+  protected static boolean isFallbackEnabled() {
+    try {
+      return Boolean.parseBoolean(
+          getClusterSetting(Settings.Key.CALCITE_FALLBACK_ALLOWED.getKeyValue(), "persistent"));
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
   }
 
-  public static void withFallbackEnabled(Runnable f, String msg) throws IOException {
+  public static void withFallbackEnabled(Runnable f, String msg) {
     LOG.info("Need fallback to v2 due to {}", msg);
     boolean isFallbackEnabled = isFallbackEnabled();
     if (isFallbackEnabled) f.run();
     else {
       try {
-        updateClusterSettings(
-            new SQLIntegTestCase.ClusterSetting(
-                "persistent", Settings.Key.CALCITE_FALLBACK_ALLOWED.getKeyValue(), "true"));
+        try {
+          updateClusterSettings(
+              new SQLIntegTestCase.ClusterSetting(
+                  "persistent", Settings.Key.CALCITE_FALLBACK_ALLOWED.getKeyValue(), "true"));
+        } catch (IOException e) {
+          throw new RuntimeException(e);
+        }
         LOG.info(
             "Set {} to enabled and run the test", Settings.Key.CALCITE_FALLBACK_ALLOWED.name());
         f.run();
       } finally {
-        updateClusterSettings(
-            new SQLIntegTestCase.ClusterSetting(
-                "persistent", Settings.Key.CALCITE_FALLBACK_ALLOWED.getKeyValue(), "false"));
+        try {
+          updateClusterSettings(
+              new SQLIntegTestCase.ClusterSetting(
+                  "persistent", Settings.Key.CALCITE_FALLBACK_ALLOWED.getKeyValue(), "false"));
+        } catch (IOException e) {
+          throw new RuntimeException(e);
+        }
         LOG.info("Reset {} back to disabled", Settings.Key.CALCITE_FALLBACK_ALLOWED.name());
       }
     }