Downgrade langauge level to java 11

Signed-off-by: Yuanchun Shen <yuanchu@amazon.com>

Author: yuancu

opensearch/src/main/java/org/opensearch/sql/opensearch/request/AggregateAnalyzer.java

@@ -238,7 +238,7 @@ public static Pair<List<AggregationBuilder>, OpenSearchAggregationResponseParser
         Set<Integer> aggPushed = aggPushedAndAggBuilder.getLeft();
         AggregationBuilder pushedAggBuilder = aggPushedAndAggBuilder.getRight();
         // The group-by list after removing pushed aggregations
-        groupList = groupList.stream().filter(i -> !aggPushed.contains(i)).toList();
+        groupList = groupList.stream().filter(i -> !aggPushed.contains(i)).collect(Collectors.toList());
         if (pushedAggBuilder != null) {
           subBuilder = new Builder().addAggregator(pushedAggBuilder);
         }
@@ -667,36 +667,47 @@ private static AutoDateHistogramAggregationBuilder analyzeAutoDateSpan(
   }
 
   private static boolean isAutoDateSpan(RexNode rex) {
-    return rex instanceof RexCall rexCall
-        && rexCall.getKind() == SqlKind.OTHER_FUNCTION
-        && rexCall.getOperator().equals(WIDTH_BUCKET);
+    if (rex instanceof RexCall) {
+      RexCall rexCall = (RexCall) rex;
+      return rexCall.getKind() == SqlKind.OTHER_FUNCTION
+          && rexCall.getOperator().equals(WIDTH_BUCKET);
+    }
+    return false;
   }
 
   private static boolean isCase(RexNode rex) {
-    return rex instanceof RexCall rexCall && rexCall.getKind() == SqlKind.CASE;
+    if (rex instanceof RexCall) {
+      RexCall rexCall = (RexCall) rex;
+      return rexCall.getKind() == SqlKind.CASE;
+    }
+    return false;
   }
 
   private static CompositeValuesSourceBuilder<?> createCompositeBucket(
       Integer groupIndex, Project project, AggregateAnalyzer.AggregateBuilderHelper helper) {
     RexNode rex = project.getProjects().get(groupIndex);
     String bucketName = project.getRowType().getFieldNames().get(groupIndex);
-    if (rex instanceof RexCall rexCall
-        && rexCall.getKind() == SqlKind.OTHER_FUNCTION
-        && rexCall.getOperator().getName().equalsIgnoreCase(BuiltinFunctionName.SPAN.name())
-        && rexCall.getOperands().size() == 3
-        && rexCall.getOperands().get(0) instanceof RexInputRef rexInputRef
-        && rexCall.getOperands().get(1) instanceof RexLiteral valueLiteral
-        && rexCall.getOperands().get(2) instanceof RexLiteral unitLiteral) {
-      return CompositeAggregationBuilder.buildHistogram(
-          bucketName,
-          helper.inferNamedField(((RexCall) rex).getOperands().get(0)).getRootName(),
-          ((RexLiteral)((RexCall) rex).getOperands().get(1)).getValueAs(Double.class),
-          SpanUnit.of(((RexLiteral)((RexCall) rex).getOperands().get(2)).getValueAs(String.class)),
-          MissingOrder.FIRST,
-          helper.bucketNullable);
-    } else {
-      return createTermsSourceBuilder(bucketName, rex, helper);
+    if (rex instanceof RexCall) {
+      RexCall rexCall = (RexCall) rex;
+      if (rexCall.getKind() == SqlKind.OTHER_FUNCTION
+          && rexCall.getOperator().getName().equalsIgnoreCase(BuiltinFunctionName.SPAN.name())
+          && rexCall.getOperands().size() == 3
+          && rexCall.getOperands().get(0) instanceof RexInputRef
+          && rexCall.getOperands().get(1) instanceof RexLiteral
+          && rexCall.getOperands().get(2) instanceof RexLiteral) {
+        RexInputRef rexInputRef = (RexInputRef) rexCall.getOperands().get(0);
+        RexLiteral valueLiteral = (RexLiteral) rexCall.getOperands().get(1);
+        RexLiteral unitLiteral = (RexLiteral) rexCall.getOperands().get(2);
+        return CompositeAggregationBuilder.buildHistogram(
+            bucketName,
+            helper.inferNamedField(rexInputRef).getRootName(),
+            valueLiteral.getValueAs(Double.class),
+            SpanUnit.of(unitLiteral.getValueAs(String.class)),
+            MissingOrder.FIRST,
+            helper.bucketNullable);
+      }
     }
+    return createTermsSourceBuilder(bucketName, rex, helper);
   }
 
   private static CompositeValuesSourceBuilder<?> createTermsSourceBuilder(

opensearch/src/main/java/org/opensearch/sql/opensearch/request/CaseRangeAnalyzer.java

@@ -86,7 +86,7 @@ public Optional<RangeAggregationBuilder> analyze(RexCall caseCall) {
     }
 
     // Check ELSE clause
-    RexNode elseExpr = operands.getLast();
+    RexNode elseExpr = operands.get(operands.size() - 1);
     String elseKey;
     if (RexLiteral.isNullLiteral(elseExpr)) {
       // range key doesn't support values of type: VALUE_NULL
@@ -168,20 +168,20 @@ private void analyzeSimpleComparison(RexCall call, String key) {
       throwUnsupported("Cannot parse value for comparison");
     }
     switch (operator.getKind()) {
-      case GREATER_THAN_OR_EQUAL -> {
+      case GREATER_THAN_OR_EQUAL:
         addFrom(key, value);
-      }
-      case LESS_THAN -> {
+        break;
+      case LESS_THAN:
         addTo(key, value);
-      }
-      default -> throw new UnsupportedOperationException(
-          "ranges must be equivalents of field >= constant or field < constant");
+        break;
+      default:
+        throw new UnsupportedOperationException(
+            "ranges must be equivalents of field >= constant or field < constant");
     }
-    ;
   }
 
   private void analyzeSearchCondition(RexCall searchCall, String key) {
-    RexNode field = searchCall.getOperands().getFirst();
+    RexNode field = searchCall.getOperands().get(0);
     if (!(field instanceof RexInputRef)) {
       throwUnsupported("Range query must be performed on a field");
     }
@@ -191,7 +191,7 @@ private void analyzeSearchCondition(RexCall searchCall, String key) {
     } else if (!Objects.equals(builder.field(), fieldName)) {
       throwUnsupported("Range query must be performed on the same field");
     }
-    RexLiteral literal = (RexLiteral) searchCall.getOperands().getLast();
+    RexLiteral literal = (RexLiteral) searchCall.getOperands().get(searchCall.getOperands().size() - 1);
     Sarg<?> sarg = Objects.requireNonNull(literal.getValueAs(Sarg.class));
     for (Range<?> r : sarg.rangeSet.asRanges()) {
       @SuppressWarnings("unchecked")

opensearch/src/main/java/org/opensearch/sql/opensearch/response/agg/BucketAggregationParser.java

@@ -126,7 +126,8 @@ public List<Map<String, Object>> parse(SearchHits hits) {
   protected Optional<Map<String, Object>> extract(
       MultiBucketsAggregation.Bucket bucket, String name) {
     Map<String, Object> extracted;
-    if (bucket instanceof CompositeAggregation.Bucket compositeBucket) {
+    if (bucket instanceof CompositeAggregation.Bucket) {
+      CompositeAggregation.Bucket compositeBucket = (CompositeAggregation.Bucket) bucket;
       extracted = compositeBucket.getKey();
     } else if (bucket instanceof Range.Bucket
         || bucket instanceof InternalAutoDateHistogram.Bucket

opensearch/src/test/java/org/opensearch/sql/opensearch/request/AggregateAnalyzerTest.java

@@ -18,6 +18,8 @@
 import java.util.Map;
 import java.util.function.Consumer;
 import java.util.function.Function;
+import java.util.stream.Collectors;
+
 import org.apache.calcite.rel.RelCollations;
 import org.apache.calcite.rel.RelNode;
 import org.apache.calcite.rel.core.Aggregate;
@@ -596,7 +598,7 @@ private Project createMockProject(List<Integer> refIndex) {
       rexNodes.add(ref);
     }
     List<org.apache.calcite.util.Pair<RexNode, String>> namedProjects =
-        rexNodes.stream().map(n -> org.apache.calcite.util.Pair.of(n, n.toString())).toList();
+        rexNodes.stream().map(n -> org.apache.calcite.util.Pair.of(n, n.toString())).collect(Collectors.toList());
     when(project.getProjects()).thenReturn(rexNodes);
     when(project.getRowType()).thenReturn(rowType);
     when(project.getNamedProjects()).thenReturn(namedProjects);