Revert SPL settings

Signed-off-by: Lantao Jin <ltjin@amazon.com>

Author: LantaoJin

async-query-core/src/main/java/org/opensearch/sql/spark/validator/PPLQueryValidator.java

@@ -45,7 +45,6 @@ public static OpenSearchPPLParser getPplParser(String pplQuery) {
         new OpenSearchPPLParser(
             new CommonTokenStream(new OpenSearchPPLLexer(new CaseInsensitiveCharStream(pplQuery))));
     sqlBaseParser.addErrorListener(new SyntaxAnalysisErrorListener());
-    // TODO add SPL compatible grammar supporting in Async Q?
     return sqlBaseParser;
   }
 }

common/src/main/java/org/opensearch/sql/common/setting/Settings.java

@@ -29,7 +29,6 @@ public enum Key {
     PATTERN_MODE("plugins.ppl.pattern.mode"),
     PATTERN_MAX_SAMPLE_COUNT("plugins.ppl.pattern.max.sample.count"),
     PATTERN_BUFFER_LIMIT("plugins.ppl.pattern.buffer.limit"),
-    SPL_COMPATIBLE_GRAMMAR_ENABLED("plugins.ppl.spl_compatible.enabled"),
 
     /** Enable Calcite as execution engine */
     CALCITE_ENGINE_ENABLED("plugins.calcite.enabled"),

core/src/main/java/org/opensearch/sql/calcite/CalcitePlanContext.java

@@ -35,7 +35,6 @@ public class CalcitePlanContext {
   public final FunctionProperties functionProperties;
   public final QueryType queryType;
   public final Integer querySizeLimit;
-  public final boolean splCompatible;
 
   @Getter @Setter private boolean isResolvingJoinCondition = false;
   @Getter @Setter private boolean isResolvingSubquery = false;
@@ -53,8 +52,7 @@ public class CalcitePlanContext {
 
   @Getter public Map<String, RexLambdaRef> rexLambdaRefMap;
 
-  private CalcitePlanContext(
-      FrameworkConfig config, Integer querySizeLimit, QueryType queryType, boolean splCompatible) {
+  private CalcitePlanContext(FrameworkConfig config, Integer querySizeLimit, QueryType queryType) {
     this.config = config;
     this.querySizeLimit = querySizeLimit;
     this.queryType = queryType;
@@ -63,7 +61,6 @@ private CalcitePlanContext(
     this.rexBuilder = new ExtendedRexBuilder(relBuilder.getRexBuilder());
     this.functionProperties = new FunctionProperties(QueryType.PPL);
     this.rexLambdaRefMap = new HashMap<>();
-    this.splCompatible = splCompatible;
   }
 
   public RexNode resolveJoinCondition(
@@ -96,12 +93,12 @@ public Optional<RexCorrelVariable> peekCorrelVar() {
   }
 
   public CalcitePlanContext clone() {
-    return new CalcitePlanContext(config, querySizeLimit, queryType, splCompatible);
+    return new CalcitePlanContext(config, querySizeLimit, queryType);
   }
 
   public static CalcitePlanContext create(
-      FrameworkConfig config, Integer querySizeLimit, QueryType queryType, boolean splCompatible) {
-    return new CalcitePlanContext(config, querySizeLimit, queryType, splCompatible);
+      FrameworkConfig config, Integer querySizeLimit, QueryType queryType) {
+    return new CalcitePlanContext(config, querySizeLimit, queryType);
   }
 
   public void putRexLambdaRefMap(Map<String, RexLambdaRef> candidateMap) {

core/src/main/java/org/opensearch/sql/calcite/CalciteRelNodeVisitor.java

@@ -676,7 +676,7 @@ private Optional<RexLiteral> extractAliasLiteral(RexNode node) {
   public RelNode visitJoin(Join node, CalcitePlanContext context) {
     List<UnresolvedPlan> children = node.getChildren();
     children.forEach(c -> analyze(c, context));
-    if (context.splCompatible && node.getJoinCondition().isEmpty()) {
+    if (node.getJoinCondition().isEmpty()) {
       // For spl compatible grammar
       List<String> leftColumns = context.relBuilder.peek(1).getRowType().getFieldNames();
       List<String> rightColumns = context.relBuilder.peek().getRowType().getFieldNames();
@@ -722,9 +722,7 @@ public RelNode visitJoin(Join node, CalcitePlanContext context) {
       }
       return context.relBuilder.peek();
     }
-    // For PPL native grammar
-    // not allowed: node.getJoinCondition().isEmpty() = true && context.splCompatible = false
-    // here is: node.getJoinCondition().isEmpty() = false
+    // The join old grammar doesn't allow empty join condition
     RexNode joinCondition =
         node.getJoinCondition()
             .map(c -> rexVisitor.analyzeJoinCondition(c, context))

core/src/main/java/org/opensearch/sql/executor/QueryService.java

@@ -133,7 +133,7 @@ public void explainWithCalcite(
               () -> {
                 CalcitePlanContext context =
                     CalcitePlanContext.create(
-                        buildFrameworkConfig(), getQuerySizeLimit(), queryType, isSplCompatible());
+                        buildFrameworkConfig(), getQuerySizeLimit(), queryType);
                 RelNode relNode = analyze(plan, context);
                 RelNode optimized = optimize(relNode, context);
                 RelNode calcitePlan = convertToCalcitePlan(optimized);
@@ -281,10 +281,6 @@ private Integer getQuerySizeLimit() {
     return settings == null ? null : settings.getSettingValue(Key.QUERY_SIZE_LIMIT);
   }
 
-  private boolean isSplCompatible() {
-    return settings == null ? false : settings.getSettingValue(Key.SPL_COMPATIBLE_GRAMMAR_ENABLED);
-  }
-
   // TODO https://github.com/opensearch-project/sql/issues/3457
   // Calcite is not available for SQL query now. Maybe release in 3.1.0?
   private boolean shouldUseCalcite(QueryType queryType) {

core/src/test/java/org/opensearch/sql/calcite/CalciteRexNodeVisitorTest.java

@@ -66,7 +66,7 @@ public void setUpContext() {
 
     mockedStatic.when(() -> CalciteToolsHelper.create(any(), any(), any())).thenReturn(relBuilder);
 
-    context = CalcitePlanContext.create(frameworkConfig, 100, QueryType.PPL, true);
+    context = CalcitePlanContext.create(frameworkConfig, 100, QueryType.PPL);
   }
 
   @AfterEach

docs/user/admin/settings.rst

@@ -792,16 +792,4 @@ If Calcite pushdown optimization is enabled, this setting is used to estimate th
 
 1. The default value is 0.9 since 3.1.0.
 2. This setting is node scope.
-3. This setting can be updated dynamically.
-
-plugins.ppl.spl_compatible.enabled
-==================================
-
-Description
------------
-
-This setting is present from 3.2.0. Enabling Calcite is a prerequisite. You can use this setting to decide whether to allow parsing a query of Splunk SPL compatible grammar.
-
-1. The default value is false.
-2. This setting is node scope.
-3. This setting can be updated dynamically.
+3. This setting can be updated dynamically.

docs/user/ppl/admin/settings.rst

@@ -89,38 +89,6 @@ PPL query::
       "transient": {}
     }
 
-plugins.ppl.spl_compatible.enabled
-==================================
-
-Description
------------
-
-This setting is present from 3.2.0. Enabling Calcite is a prerequisite. You can use this setting to decide whether to allow parsing a query of Splunk SPL compatible grammar.
-
-1. The default value is false.
-2. This setting is node scope.
-3. This setting can be updated dynamically.
-
-Example
--------
-
-PPL query::
-
-    sh$ curl -sS -H 'Content-Type: application/json' \
-    ... -X PUT localhost:9200/_plugins/_query/settings \
-    ... -d '{"persistent" : {"plugins.ppl.spl_compatible.enabled" : "true"}}'
-    {
-      "acknowledged": true,
-      "persistent": {
-        "plugins": {
-          "spl_compatible": {
-            "enabled": "true"
-          }
-        }
-      },
-      "transient": {}
-    }
-
 plugins.query.memory_limit
 ==========================
 

docs/user/ppl/cmd/join.rst

@@ -11,39 +11,35 @@ join
 
 Description
 ===========
-| (Experimental)
-| (Since 3.0.0)
 | Using ``join`` command to combines two datasets together. The left side could be an index or results from a piped commands, the right side could be either an index or a subsearch.
 
 Version
 =======
 3.0.0
 
-Syntax
-======
-[joinType] join [leftAlias] [rightAlias] on <joinCriteria> <right-dataset>
+Syntax-1
+========
+| [joinType] join [leftAlias] [rightAlias] on <joinCriteria> <right-dataset>
 
 * joinType: optional. The type of join to perform. The default is ``INNER`` if not specified. Other option is ``LEFT [OUTER]``, ``RIGHT [OUTER]``, ``FULL [OUTER]``, ``CROSS``, ``[LEFT] SEMI``, ``[LEFT] ANTI``.
 * leftAlias: optional. The subsearch alias to use with the left join side, to avoid ambiguous naming. Fixed pattern: ``left = <leftAlias>``
 * rightAlias: optional. The subsearch alias to use with the right join side, to avoid ambiguous naming. Fixed pattern: ``right = <rightAlias>``
 * joinCriteria: mandatory. It could be any comparison expression.
-* right-dataset: mandatory. Right dataset could be either an index or a subsearch with/without alias.
+* right-dataset: mandatory. Right dataset could be either an ``index`` or a ``subsearch`` with/without alias.
 
-SPL Compatible Syntax
-=====================
-| (Experimental)
-| (Since 3.2.0)
-| (prerequisite: plugins.ppl.spl_compatible.enabled=true)
+Syntax-2
+========
+| (Since 3.3.0)
 | join [type=<joinType>] [overwrite=<bool>] <join-field-list> <right-dataset>
 
 * type=<joinType>: optional. The type of join to perform. The default is ``INNER`` if not specified. Other option is ``LEFT``, ``RIGHT``, ``FULL``, ``CROSS``, ``SEMI``, ``ANTI``.
 * overwrite=<bool>: optional. Specifies whether duplicate-named fields from <right-dataset> (subsearch results) should replace corresponding fields in the main search results. The default value is ``true``.
 * join-field-list: optional. The fields to use to build join criteria. The ``join-field-list`` must be present in both sides. If no <join-field-list> is present, all fields that are common to both sides are used.
-* right-dataset: mandatory. Right dataset could be either an index or a subsearch with/without alias.
+* right-dataset: mandatory. Right dataset could be either an ``index`` or a ``subsearch`` with/without alias.
 
 Configuration
 =============
-This command requires Calcite enabled. In 3.0.0-beta, as an experimental the Calcite configuration is disabled by default.
+This command requires Calcite enabled. In 3.0.0, as an experimental the Calcite configuration is disabled by default.
 
 Enable Calcite::
 
@@ -70,7 +66,7 @@ Result set::
 Usage
 =====
 
-Join::
+Join (syntax-1)::
 
     source = table1 | inner join left = l right = r on l.a = r.a table2 | fields l.a, r.a, b, c
     source = table1 | left join left = l right = r on l.a = r.a table2 | fields l.a, r.a, b, c
@@ -85,6 +81,9 @@ Join::
     source = table1 as t1 | join left = l right = r on l.a = r.a table2 as t2 | fields l.a, r.a
     source = table1 as t1 | join left = l right = r on l.a = r.a table2 as t2 | fields t1.a, t2.a
     source = table1 | join left = l right = r on l.a = r.a [ source = table2 ] as s | fields l.a, s.a
+
+Join (syntax-2)::
+
     source = table1 | join a table2 | fields a, b, c
     source = table1 | join a, b table2 | fields a, b, c
     source = table1 | join type=left overwrite=false a, b [source=table2 | rename d as b] | fields a, b, c
@@ -158,7 +157,7 @@ PPL query::
 
 Limitation
 ==========
-If fields in the left outputs and right outputs have the same name. Typically, in the join criteria
+In syntax-1, if fields in the left outputs and right outputs have the same name. Typically, in the join criteria
 ``ON t1.id = t2.id``, the names ``id`` in output are ambiguous. To avoid ambiguous, the ambiguous
 fields in output rename to ``<alias>.id``, or else ``<tableName>.id`` if no alias existing.
 
@@ -179,4 +178,4 @@ Assume table1 and table2 only contain field ``id``, following PPL queries and th
    * - source=table1 | join right=tt on table1.id=t2.id [ source=table2 as t2 | eval b = id ] | eval a = 1
      - table1.id, tt.id, tt.b, a
 
-For the Splunk SPL compatible syntax (since 3.2.0), duplicate-named fields in output results are deduplicated, with field retention determined by the value of 'overwrite' option.
+But for the syntax-2 (since 3.2.0), duplicate-named fields in output results are deduplicated, with field retention determined by the value of 'overwrite' option.