Adding filter for bucketNullable=false by hint strategy

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

@@ -132,6 +132,7 @@
 import org.opensearch.sql.ast.tree.Values;
 import org.opensearch.sql.ast.tree.Window;
 import org.opensearch.sql.calcite.plan.OpenSearchConstants;
+import org.opensearch.sql.calcite.plan.OpenSearchHints;
 import org.opensearch.sql.calcite.utils.BinUtils;
 import org.opensearch.sql.calcite.utils.JoinAndLookupUtils;
 import org.opensearch.sql.calcite.utils.PlanUtils;
@@ -1030,21 +1031,7 @@ public RelNode visitAggregation(Aggregation node, CalcitePlanContext context) {
     Argument.ArgumentMap statsArgs = Argument.ArgumentMap.of(node.getArgExprList());
     Boolean bucketNullable =
         (Boolean) statsArgs.getOrDefault(Argument.BUCKET_NULLABLE, Literal.TRUE).getValue();
-    boolean toAddHintsOnAggregate = false;
-    if (!bucketNullable
-        && !groupExprList.isEmpty()
-        && !(groupExprList.size() == 1 && getTimeSpanField(span).isPresent())) {
-      toAddHintsOnAggregate = true;
-      // add isNotNull filter before aggregation for non-nullable buckets
-      List<RexNode> groupByList =
-          groupExprList.stream().map(expr -> rexVisitor.analyze(expr, context)).toList();
-      context.relBuilder.filter(
-          PlanUtils.getSelectColumns(groupByList).stream()
-              .map(context.relBuilder::field)
-              .map(context.relBuilder::isNotNull)
-              .toList());
-    }
-
+    boolean toAddHintsOnAggregate = !bucketNullable && !groupExprList.isEmpty() && !(groupExprList.size() == 1 && getTimeSpanField(span).isPresent());
     Pair<List<RexNode>, List<AggCall>> aggregationAttributes =
         aggregateWithTrimming(groupExprList, aggExprList, context);
     if (toAddHintsOnAggregate) {
@@ -1056,14 +1043,9 @@ public RelNode visitAggregation(Aggregation node, CalcitePlanContext context) {
       context
           .relBuilder
           .getCluster()
-          .setHintStrategies(
-              HintStrategyTable.builder()
-                  .hintStrategy(
-                      "stats_args",
-                      (hint, rel) -> {
-                        return rel instanceof LogicalAggregate;
-                      })
-                  .build());
+          .setHintStrategies(HintStrategyTable.builder().hintStrategy(
+              "stats_args", OpenSearchHints.aggStatsArgs)
+              .build());
     }
 
     // schema reordering

core/src/main/java/org/opensearch/sql/calcite/plan/OpenSearchHints.java

@@ -0,0 +1,23 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.calcite.plan;
+
+import static org.apache.calcite.adapter.enumerable.EnumerableRules.ENUMERABLE_AGGREGATE_RULE;
+
+import org.apache.calcite.rel.hint.HintStrategy;
+import org.apache.calcite.rel.logical.LogicalAggregate;
+
+public class OpenSearchHints {
+
+  public static final HintStrategy aggStatsArgs =
+      HintStrategy.builder((hint, rel) -> hint.hintName.equals("stats_args") && rel instanceof LogicalAggregate)
+      .excludedRules(ENUMERABLE_AGGREGATE_RULE)
+      .converterRules(OpenSearchRules.AGGREGATE_HINT_CONVERT_RULE)
+      .build();
+
+  // prevent instantiation
+  private OpenSearchHints() {}
+}

core/src/main/java/org/opensearch/sql/calcite/plan/OpenSearchRules.java

@@ -13,8 +13,12 @@ public class OpenSearchRules {
   private static final PPLAggregateConvertRule AGGREGATE_CONVERT_RULE =
       PPLAggregateConvertRule.Config.SUM_CONVERTER.toRule();
 
+  public static final PPLAggregateHintConvertRule AGGREGATE_HINT_CONVERT_RULE =
+      PPLAggregateHintConvertRule.DEFAULT_CONFIG.toRule(PPLAggregateHintConvertRule.class);
+
+
   public static final List<RelOptRule> OPEN_SEARCH_OPT_RULES =
-      ImmutableList.of(AGGREGATE_CONVERT_RULE);
+      ImmutableList.of(AGGREGATE_CONVERT_RULE, AGGREGATE_HINT_CONVERT_RULE);
 
   // prevent instantiation
   private OpenSearchRules() {}

core/src/main/java/org/opensearch/sql/calcite/plan/PPLAggregateHintConvertRule.java

@@ -0,0 +1,63 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.calcite.plan;
+
+import java.util.List;
+import org.apache.calcite.adapter.enumerable.EnumerableAggregate;
+import org.apache.calcite.adapter.enumerable.EnumerableConvention;
+import org.apache.calcite.plan.Convention;
+import org.apache.calcite.plan.RelTraitSet;
+import org.apache.calcite.rel.InvalidRelException;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.convert.ConverterRule;
+import org.apache.calcite.rel.logical.LogicalAggregate;
+import org.apache.calcite.rel.logical.LogicalFilter;
+import org.apache.calcite.rex.RexBuilder;
+import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.rex.RexUtil;
+import org.apache.calcite.sql.fun.SqlStdOperatorTable;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.immutables.value.Value;
+
+@Value.Enclosing
+class PPLAggregateHintConvertRule extends ConverterRule {
+  /** Default configuration. */
+  static final Config DEFAULT_CONFIG = Config.INSTANCE
+      .withConversion(LogicalAggregate.class, PPLAggregateHintConvertRule::containsStatsArgsHint,
+          Convention.NONE, EnumerableConvention.INSTANCE, "PPLAggregateHintConvertRule")
+      .withRuleFactory(PPLAggregateHintConvertRule::new);
+
+  /** Called from the Config. */
+  protected PPLAggregateHintConvertRule(Config config) {
+    super(config);
+  }
+
+  @Override public @Nullable RelNode convert(RelNode rel) {
+    final LogicalAggregate agg = (LogicalAggregate) rel;
+    RelNode input = agg.getInput();
+    RexBuilder rexBuilder = agg.getCluster().getRexBuilder();
+    List<RexNode> predicates = agg.getGroupSet().asList().stream().map(index -> rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, rexBuilder.makeInputRef(input, index))).toList();
+    RexNode condition = RexUtil.composeConjunction(rexBuilder, predicates);
+    final LogicalFilter filter = LogicalFilter.create(input, condition);
+    final RelTraitSet traitSet = rel.getCluster()
+        .traitSet().replace(EnumerableConvention.INSTANCE);
+    try {
+      return new EnumerableAggregate(
+          rel.getCluster(),
+          traitSet,
+          convert(filter, traitSet),
+          agg.getGroupSet(),
+          agg.getGroupSets(),
+          agg.getAggCallList());
+    } catch (InvalidRelException e) {
+      return null;
+    }
+  }
+
+  public static boolean containsStatsArgsHint(LogicalAggregate agg) {
+    return agg.getHints().stream().anyMatch(hint -> hint.hintName.equals("stats_args"));
+  }
+}

integ-test/src/test/resources/expectedOutput/calcite/explain_agg_sort_on_metrics1.json

@@ -1,6 +1 @@
-{
-  "calcite": {
-    "logical": "LogicalSystemLimit(sort0=[$0], dir0=[ASC-nulls-first], fetch=[10000], type=[QUERY_SIZE_LIMIT])\n  LogicalSort(sort0=[$0], dir0=[ASC-nulls-first])\n    LogicalProject(count()=[$1], state=[$0])\n      LogicalAggregate(group=[{0}], count()=[COUNT()])\n        LogicalProject(state=[$7])\n          LogicalFilter(condition=[IS NOT NULL($7)])\n            CalciteLogicalIndexScan(table=[[OpenSearch, opensearch-sql_test_index_account]])\n",
-    "physical": "EnumerableLimit(fetch=[10000])\n  EnumerableSort(sort0=[$0], dir0=[ASC-nulls-first])\n    CalciteEnumerableIndexScan(table=[[OpenSearch, opensearch-sql_test_index_account]], PushDownContext=[[FILTER->IS NOT NULL($7), AGGREGATION->rel#:LogicalAggregate.NONE.[](input=RelSubset#,group={0},count()=COUNT()), PROJECT->[count(), state]], OpenSearchRequestBuilder(sourceBuilder={\"from\":0,\"size\":0,\"timeout\":\"1m\",\"query\":{\"exists\":{\"field\":\"state\",\"boost\":1.0}},\"sort\":[],\"aggregations\":{\"composite_buckets\":{\"composite\":{\"size\":1000,\"sources\":[{\"state\":{\"terms\":{\"field\":\"state.keyword\",\"missing_bucket\":false,\"order\":\"asc\"}}}]}}}}, requestedTotalSize=2147483647, pageSize=null, startFrom=0)])\n"
-  }
-}
+{"calcite":{"logical":"LogicalSystemLimit(sort0=[$0], dir0=[ASC-nulls-first], fetch=[10000], type=[QUERY_SIZE_LIMIT])\n  LogicalSort(sort0=[$0], dir0=[ASC-nulls-first])\n    LogicalProject(count()=[$1], state=[$0])\n      LogicalAggregate(group=[{0}], count()=[COUNT()])\n        LogicalProject(state=[$7])\n          CalciteLogicalIndexScan(table=[[OpenSearch, opensearch-sql_test_index_account]])\n","physical":"EnumerableLimit(fetch=[10000])\n  EnumerableSort(sort0=[$0], dir0=[ASC-nulls-first])\n    CalciteEnumerableIndexScan(table=[[OpenSearch, opensearch-sql_test_index_account]], PushDownContext=[[AGGREGATION->rel#:LogicalAggregate.NONE.[](input=RelSubset#,group={0},count()=COUNT()), PROJECT->[count(), state]], OpenSearchRequestBuilder(sourceBuilder={\"from\":0,\"size\":0,\"timeout\":\"1m\",\"aggregations\":{\"composite_buckets\":{\"composite\":{\"size\":1000,\"sources\":[{\"state\":{\"terms\":{\"field\":\"state.keyword\",\"missing_bucket\":false,\"order\":\"asc\"}}}]}}}}, requestedTotalSize=2147483647, pageSize=null, startFrom=0)])\n"}}

integ-test/src/test/resources/expectedOutput/calcite/explain_agg_sort_on_metrics2.json

@@ -1,6 +1 @@
-{
-  "calcite": {
-    "logical": "LogicalSystemLimit(sort0=[$0], dir0=[ASC-nulls-first], fetch=[10000], type=[QUERY_SIZE_LIMIT])\n  LogicalSort(sort0=[$0], dir0=[ASC-nulls-first])\n    LogicalProject(count()=[$2], gender=[$0], state=[$1])\n      LogicalAggregate(group=[{0, 1}], count()=[COUNT()])\n        LogicalProject(gender=[$4], state=[$7])\n          LogicalFilter(condition=[AND(IS NOT NULL($4), IS NOT NULL($7))])\n            CalciteLogicalIndexScan(table=[[OpenSearch, opensearch-sql_test_index_account]])\n",
-    "physical": "EnumerableLimit(fetch=[10000])\n  EnumerableSort(sort0=[$0], dir0=[ASC-nulls-first])\n    CalciteEnumerableIndexScan(table=[[OpenSearch, opensearch-sql_test_index_account]], PushDownContext=[[FILTER->AND(IS NOT NULL($4), IS NOT NULL($7)), AGGREGATION->rel#:LogicalAggregate.NONE.[](input=RelSubset#,group={0, 1},count()=COUNT()), PROJECT->[count(), gender, state]], OpenSearchRequestBuilder(sourceBuilder={\"from\":0,\"size\":0,\"timeout\":\"1m\",\"query\":{\"bool\":{\"must\":[{\"exists\":{\"field\":\"gender\",\"boost\":1.0}},{\"exists\":{\"field\":\"state\",\"boost\":1.0}}],\"adjust_pure_negative\":true,\"boost\":1.0}},\"sort\":[],\"aggregations\":{\"composite_buckets\":{\"composite\":{\"size\":1000,\"sources\":[{\"gender\":{\"terms\":{\"field\":\"gender.keyword\",\"missing_bucket\":false,\"order\":\"asc\"}}},{\"state\":{\"terms\":{\"field\":\"state.keyword\",\"missing_bucket\":false,\"order\":\"asc\"}}}]}}}}, requestedTotalSize=2147483647, pageSize=null, startFrom=0)])\n"
-  }
-}
+{"calcite":{"logical":"LogicalSystemLimit(sort0=[$0], dir0=[ASC-nulls-first], fetch=[10000], type=[QUERY_SIZE_LIMIT])\n  LogicalSort(sort0=[$0], dir0=[ASC-nulls-first])\n    LogicalProject(count()=[$2], gender=[$0], state=[$1])\n      LogicalAggregate(group=[{0, 1}], count()=[COUNT()])\n        LogicalProject(gender=[$4], state=[$7])\n          CalciteLogicalIndexScan(table=[[OpenSearch, opensearch-sql_test_index_account]])\n","physical":"EnumerableLimit(fetch=[10000])\n  EnumerableSort(sort0=[$0], dir0=[ASC-nulls-first])\n    CalciteEnumerableIndexScan(table=[[OpenSearch, opensearch-sql_test_index_account]], PushDownContext=[[AGGREGATION->rel#:LogicalAggregate.NONE.[](input=RelSubset#,group={0, 1},count()=COUNT()), PROJECT->[count(), gender, state]], OpenSearchRequestBuilder(sourceBuilder={\"from\":0,\"size\":0,\"timeout\":\"1m\",\"aggregations\":{\"composite_buckets\":{\"composite\":{\"size\":1000,\"sources\":[{\"gender\":{\"terms\":{\"field\":\"gender.keyword\",\"missing_bucket\":false,\"order\":\"asc\"}}},{\"state\":{\"terms\":{\"field\":\"state.keyword\",\"missing_bucket\":false,\"order\":\"asc\"}}}]}}}}, requestedTotalSize=2147483647, pageSize=null, startFrom=0)])\n"}}

integ-test/src/test/resources/expectedOutput/calcite/explain_limit_agg_pushdown_bucket_nullable1.json

@@ -1,6 +1 @@
-{
-  "calcite": {
-    "logical": "LogicalSystemLimit(fetch=[10000], type=[QUERY_SIZE_LIMIT])\n  LogicalSort(offset=[10], fetch=[10])\n    LogicalSort(fetch=[100])\n      LogicalProject(count()=[$1], state=[$0])\n        LogicalAggregate(group=[{0}], count()=[COUNT()])\n          LogicalProject(state=[$7])\n            LogicalFilter(condition=[IS NOT NULL($7)])\n              CalciteLogicalIndexScan(table=[[OpenSearch, opensearch-sql_test_index_account]])\n",
-    "physical": "EnumerableLimit(fetch=[10000])\n  EnumerableCalc(expr#0..1=[{inputs}], count()=[$t1], state=[$t0])\n    EnumerableLimit(offset=[10], fetch=[10])\n      CalciteEnumerableIndexScan(table=[[OpenSearch, opensearch-sql_test_index_account]], PushDownContext=[[FILTER->IS NOT NULL($7), AGGREGATION->rel#:LogicalAggregate.NONE.[](input=RelSubset#,group={0},count()=COUNT()), LIMIT->100, LIMIT->[10 from 10]], OpenSearchRequestBuilder(sourceBuilder={\"from\":0,\"size\":0,\"timeout\":\"1m\",\"query\":{\"exists\":{\"field\":\"state\",\"boost\":1.0}},\"sort\":[],\"aggregations\":{\"composite_buckets\":{\"composite\":{\"size\":20,\"sources\":[{\"state\":{\"terms\":{\"field\":\"state.keyword\",\"missing_bucket\":false,\"order\":\"asc\"}}}]}}}}, requestedTotalSize=2147483647, pageSize=null, startFrom=0)])\n"
-  }
-}
+{"calcite":{"logical":"LogicalSystemLimit(fetch=[10000], type=[QUERY_SIZE_LIMIT])\n  LogicalSort(offset=[10], fetch=[10])\n    LogicalSort(fetch=[100])\n      LogicalProject(count()=[$1], state=[$0])\n        LogicalAggregate(group=[{0}], count()=[COUNT()])\n          LogicalProject(state=[$7])\n            CalciteLogicalIndexScan(table=[[OpenSearch, opensearch-sql_test_index_account]])\n","physical":"EnumerableLimit(fetch=[10000])\n  EnumerableCalc(expr#0..1=[{inputs}], count()=[$t1], state=[$t0])\n    EnumerableLimit(offset=[10], fetch=[10])\n      CalciteEnumerableIndexScan(table=[[OpenSearch, opensearch-sql_test_index_account]], PushDownContext=[[AGGREGATION->rel#:LogicalAggregate.NONE.[](input=RelSubset#,group={0},count()=COUNT()), LIMIT->100, LIMIT->[10 from 10]], OpenSearchRequestBuilder(sourceBuilder={\"from\":0,\"size\":0,\"timeout\":\"1m\",\"aggregations\":{\"composite_buckets\":{\"composite\":{\"size\":20,\"sources\":[{\"state\":{\"terms\":{\"field\":\"state.keyword\",\"missing_bucket\":false,\"order\":\"asc\"}}}]}}}}, requestedTotalSize=2147483647, pageSize=null, startFrom=0)])\n"}}

integ-test/src/test/resources/expectedOutput/calcite/explain_limit_agg_pushdown_bucket_nullable2.json

@@ -1,6 +1 @@
-{
-  "calcite": {
-    "logical": "LogicalSystemLimit(fetch=[10000], type=[QUERY_SIZE_LIMIT])\n  LogicalSort(offset=[10], fetch=[10])\n    LogicalSort(sort0=[$1], dir0=[ASC-nulls-first], fetch=[100])\n      LogicalProject(count()=[$1], state=[$0])\n        LogicalAggregate(group=[{0}], count()=[COUNT()])\n          LogicalProject(state=[$7])\n            LogicalFilter(condition=[IS NOT NULL($7)])\n              CalciteLogicalIndexScan(table=[[OpenSearch, opensearch-sql_test_index_account]])\n",
-    "physical": "EnumerableLimit(fetch=[10000])\n  EnumerableCalc(expr#0..1=[{inputs}], count()=[$t1], state=[$t0])\n    EnumerableLimit(offset=[10], fetch=[10])\n      CalciteEnumerableIndexScan(table=[[OpenSearch, opensearch-sql_test_index_account]], PushDownContext=[[FILTER->IS NOT NULL($7), AGGREGATION->rel#:LogicalAggregate.NONE.[](input=RelSubset#,group={0},count()=COUNT()), SORT->[0 ASC FIRST], LIMIT->100, LIMIT->[10 from 10]], OpenSearchRequestBuilder(sourceBuilder={\"from\":0,\"size\":0,\"timeout\":\"1m\",\"query\":{\"exists\":{\"field\":\"state\",\"boost\":1.0}},\"sort\":[],\"aggregations\":{\"composite_buckets\":{\"composite\":{\"size\":20,\"sources\":[{\"state\":{\"terms\":{\"field\":\"state.keyword\",\"missing_bucket\":false,\"order\":\"asc\"}}}]}}}}, requestedTotalSize=2147483647, pageSize=null, startFrom=0)])\n"
-  }
-}
+{"calcite":{"logical":"LogicalSystemLimit(fetch=[10000], type=[QUERY_SIZE_LIMIT])\n  LogicalSort(offset=[10], fetch=[10])\n    LogicalSort(sort0=[$1], dir0=[ASC-nulls-first], fetch=[100])\n      LogicalProject(count()=[$1], state=[$0])\n        LogicalAggregate(group=[{0}], count()=[COUNT()])\n          LogicalProject(state=[$7])\n            CalciteLogicalIndexScan(table=[[OpenSearch, opensearch-sql_test_index_account]])\n","physical":"EnumerableLimit(fetch=[10000])\n  EnumerableCalc(expr#0..1=[{inputs}], count()=[$t1], state=[$t0])\n    EnumerableLimit(offset=[10], fetch=[10])\n      CalciteEnumerableIndexScan(table=[[OpenSearch, opensearch-sql_test_index_account]], PushDownContext=[[AGGREGATION->rel#:LogicalAggregate.NONE.[](input=RelSubset#,group={0},count()=COUNT()), SORT->[0 ASC FIRST], LIMIT->100, LIMIT->[10 from 10]], OpenSearchRequestBuilder(sourceBuilder={\"from\":0,\"size\":0,\"timeout\":\"1m\",\"aggregations\":{\"composite_buckets\":{\"composite\":{\"size\":20,\"sources\":[{\"state\":{\"terms\":{\"field\":\"state.keyword\",\"missing_bucket\":false,\"order\":\"asc\"}}}]}}}}, requestedTotalSize=2147483647, pageSize=null, startFrom=0)])\n"}}

integ-test/src/test/resources/expectedOutput/calcite/explain_stats_by_span_non_bucket_nullable.json

@@ -1,6 +1,6 @@
 {
   "calcite": {
-    "logical": "LogicalSystemLimit(fetch=[10000], type=[QUERY_SIZE_LIMIT])\n  LogicalProject(count()=[$1], span(age,10)=[$0])\n    LogicalAggregate(group=[{0}], count()=[COUNT()])\n      LogicalProject(span(age,10)=[SPAN($10, 10, null:NULL)])\n        LogicalFilter(condition=[IS NOT NULL($10)])\n          CalciteLogicalIndexScan(table=[[OpenSearch, opensearch-sql_test_index_bank]])\n",
-    "physical": "CalciteEnumerableIndexScan(table=[[OpenSearch, opensearch-sql_test_index_bank]], PushDownContext=[[PROJECT->[age], FILTER->IS NOT NULL($0), AGGREGATION->rel#:LogicalAggregate.NONE.[](input=RelSubset#,group={0},count()=COUNT()), PROJECT->[count(), span(age,10)], LIMIT->10000], OpenSearchRequestBuilder(sourceBuilder={\"from\":0,\"size\":0,\"timeout\":\"1m\",\"query\":{\"exists\":{\"field\":\"age\",\"boost\":1.0}},\"_source\":{\"includes\":[\"age\"],\"excludes\":[]},\"sort\":[],\"aggregations\":{\"composite_buckets\":{\"composite\":{\"size\":1000,\"sources\":[{\"span(age,10)\":{\"histogram\":{\"field\":\"age\",\"missing_bucket\":false,\"order\":\"asc\",\"interval\":10.0}}}]}}}}, requestedTotalSize=2147483647, pageSize=null, startFrom=0)])\n"
+    "logical": "LogicalSystemLimit(fetch=[10000], type=[QUERY_SIZE_LIMIT])\n  LogicalProject(count()=[$1], span(age,10)=[$0])\n    LogicalAggregate(group=[{0}], count()=[COUNT()])\n      LogicalProject(span(age,10)=[SPAN($10, 10, null:NULL)])\n        CalciteLogicalIndexScan(table=[[OpenSearch, opensearch-sql_test_index_bank]])\n",
+    "physical": "CalciteEnumerableIndexScan(table=[[OpenSearch, opensearch-sql_test_index_bank]], PushDownContext=[[AGGREGATION->rel#:LogicalAggregate.NONE.[](input=RelSubset#,group={0},count()=COUNT()), PROJECT->[count(), span(age,10)], LIMIT->10000], OpenSearchRequestBuilder(sourceBuilder={\"from\":0,\"size\":0,\"timeout\":\"1m\",\"aggregations\":{\"composite_buckets\":{\"composite\":{\"size\":1000,\"sources\":[{\"span(age,10)\":{\"histogram\":{\"field\":\"age\",\"missing_bucket\":false,\"order\":\"asc\",\"interval\":10.0}}}]}}}}, requestedTotalSize=2147483647, pageSize=null, startFrom=0)])\n"
   }
 }

integ-test/src/test/resources/expectedOutput/calcite_no_pushdown/explain_stats_by_span_non_bucket_nullable.json

@@ -1,6 +1 @@
-{
-  "calcite": {
-    "logical": "LogicalSystemLimit(fetch=[10000], type=[QUERY_SIZE_LIMIT])\n  LogicalProject(count()=[$1], span(age,10)=[$0])\n    LogicalAggregate(group=[{0}], count()=[COUNT()])\n      LogicalProject(span(age,10)=[SPAN($10, 10, null:NULL)])\n        LogicalFilter(condition=[IS NOT NULL($10)])\n          CalciteLogicalIndexScan(table=[[OpenSearch, opensearch-sql_test_index_bank]])\n",
-    "physical": "EnumerableLimit(fetch=[10000])\n  EnumerableCalc(expr#0..1=[{inputs}], count()=[$t1], span(age,10)=[$t0])\n    EnumerableAggregate(group=[{0}], count()=[COUNT()])\n      EnumerableCalc(expr#0..18=[{inputs}], expr#19=[10], expr#20=[null:NULL], expr#21=[SPAN($t10, $t19, $t20)], expr#22=[IS NOT NULL($t10)], span(age,10)=[$t21], $condition=[$t22])\n        CalciteEnumerableIndexScan(table=[[OpenSearch, opensearch-sql_test_index_bank]])\n"
-  }
-}
+{"calcite":{"logical":"LogicalSystemLimit(fetch=[10000], type=[QUERY_SIZE_LIMIT])\n  LogicalProject(count()=[$1], span(age,10)=[$0])\n    LogicalAggregate(group=[{0}], count()=[COUNT()])\n      LogicalProject(span(age,10)=[SPAN($10, 10, null:NULL)])\n        CalciteLogicalIndexScan(table=[[OpenSearch, opensearch-sql_test_index_bank]])\n","physical":"EnumerableLimit(fetch=[10000])\n  EnumerableCalc(expr#0..1=[{inputs}], count()=[$t1], span(age,10)=[$t0])\n    EnumerableAggregate(group=[{0}], count()=[COUNT()])\n      EnumerableCalc(expr#0..18=[{inputs}], expr#19=[10], expr#20=[null:NULL], expr#21=[SPAN($t10, $t19, $t20)], expr#22=[IS NOT NULL($t21)], span(age,10)=[$t21], $condition=[$t22])\n        CalciteEnumerableIndexScan(table=[[OpenSearch, opensearch-sql_test_index_bank]])\n"}}