Merge branch 'main' into issues/4631

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

Author: yuancu

.github/workflows/enforce-labels.yml

@@ -9,5 +9,5 @@ jobs:
     steps:
     - uses: yogevbd/enforce-label-action@2.1.0
       with:
-        REQUIRED_LABELS_ANY: "breaking,feature,enhancement,bug,infrastructure,dependencies,documentation,maintenance,skip-changelog,testing,security fix"
-        REQUIRED_LABELS_ANY_DESCRIPTION: "A release label is required: ['breaking', 'bug', 'dependencies', 'documentation', 'enhancement', 'feature', 'infrastructure', 'maintenance', 'skip-changelog', 'testing', 'security fix']"
+        REQUIRED_LABELS_ANY: "breaking,feature,enhancement,bugFix,infrastructure,dependencies,documentation,maintenance,skip-changelog,testing,security fix"
+        REQUIRED_LABELS_ANY_DESCRIPTION: "A release label is required: ['breaking', 'bugFix', 'dependencies', 'documentation', 'enhancement', 'feature', 'infrastructure', 'maintenance', 'skip-changelog', 'testing', 'security fix']"

.github/workflows/integ-tests-with-security.yml

@@ -62,7 +62,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ windows-latest, macos-13 ]
+        os: [ windows-latest, macos-14 ]
         java: [21, 24]
 
     runs-on: ${{ matrix.os }}

.github/workflows/sql-test-and-build-workflow.yml

@@ -107,8 +107,8 @@ jobs:
         entry:
           - { os: windows-latest, java: 21, os_build_args: -PbuildPlatform=windows }
           - { os: windows-latest, java: 24, os_build_args: -PbuildPlatform=windows }
-          - { os: macos-13, java: 21, os_build_args: '' }
-          - { os: macos-13, java: 24, os_build_args: '' }
+          - { os: macos-14, java: 21, os_build_args: '' }
+          - { os: macos-14, java: 24, os_build_args: '' }
         test-type: ['unit', 'integration', 'doc']
         exclude:
           # Exclude doctest for Windows

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

@@ -0,0 +1,23 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.calcite.plan;
+
+import org.apache.calcite.plan.Contexts;
+import org.apache.calcite.plan.RelRule;
+import org.apache.calcite.rel.core.RelFactories;
+import org.apache.calcite.tools.RelBuilderFactory;
+import org.immutables.value.Value;
+import org.opensearch.sql.calcite.utils.CalciteToolsHelper;
+
+public interface OpenSearchRuleConfig extends RelRule.Config {
+
+  /** Return a custom RelBuilderFactory for creating OpenSearchRelBuilder */
+  @Override
+  @Value.Default
+  default RelBuilderFactory relBuilderFactory() {
+    return CalciteToolsHelper.proto(Contexts.of(RelFactories.DEFAULT_STRUCT));
+  }
+}

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

@@ -105,7 +105,7 @@ public void apply(RelOptRuleCall call, LogicalAggregate aggregate, LogicalProjec
 
   /** Rule configuration. */
   @Value.Immutable
-  public interface Config extends RelRule.Config {
+  public interface Config extends OpenSearchRuleConfig {
     Config GROUP_MERGE =
         ImmutablePPLAggGroupMergeRule.Config.builder()
             .build()

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

@@ -240,7 +240,7 @@ private RexNode aliasMaybe(RelBuilder builder, RexNode node, String alias) {
 
   /** Rule configuration. */
   @Value.Immutable
-  public interface Config extends RelRule.Config {
+  public interface Config extends OpenSearchRuleConfig {
     Config SUM_CONVERTER =
         ImmutablePPLAggregateConvertRule.Config.builder()
             .build()

core/src/main/java/org/opensearch/sql/calcite/utils/CalciteToolsHelper.java

@@ -83,6 +83,7 @@
 import org.apache.calcite.tools.FrameworkConfig;
 import org.apache.calcite.tools.Frameworks;
 import org.apache.calcite.tools.RelBuilder;
+import org.apache.calcite.tools.RelBuilderFactory;
 import org.apache.calcite.tools.RelRunner;
 import org.apache.calcite.util.Holder;
 import org.apache.calcite.util.Util;
@@ -127,6 +128,10 @@ public static Connection connect(FrameworkConfig config, JavaTypeFactory typeFac
     }
   }
 
+  public static RelBuilderFactory proto(final Context context) {
+    return (cluster, schema) -> new OpenSearchRelBuilder(context, cluster, schema);
+  }
+
   /**
    * This method copied from {@link Frameworks#withPrepare(FrameworkConfig,
    * Frameworks.BasePrepareAction)}. The purpose is the method {@link

core/src/main/java/org/opensearch/sql/calcite/utils/OpenSearchTypeFactory.java

@@ -338,12 +338,12 @@ public static boolean isUserDefinedType(RelDataType type) {
   }
 
   /**
-   * Checks if the RelDataType represents a numeric field. Supports both standard SQL numeric types
-   * (INTEGER, BIGINT, SMALLINT, TINYINT, FLOAT, DOUBLE, DECIMAL, REAL) and OpenSearch UDT numeric
-   * types.
+   * Checks if the RelDataType represents a numeric type. Supports standard SQL numeric types
+   * (INTEGER, BIGINT, SMALLINT, TINYINT, FLOAT, DOUBLE, DECIMAL, REAL), OpenSearch UDT numeric
+   * types, and string types (VARCHAR, CHAR).
    *
    * @param fieldType the RelDataType to check
-   * @return true if the type is numeric, false otherwise
+   * @return true if the type is numeric or string, false otherwise
    */
   public static boolean isNumericType(RelDataType fieldType) {
     // Check standard SQL numeric types
@@ -359,6 +359,11 @@ public static boolean isNumericType(RelDataType fieldType) {
       return true;
     }
 
+    // Check string types (VARCHAR, CHAR)
+    if (sqlType == SqlTypeName.VARCHAR || sqlType == SqlTypeName.CHAR) {
+      return true;
+    }
+
     // Check for OpenSearch UDT numeric types
     if (isUserDefinedType(fieldType)) {
       AbstractExprRelDataType<?> exprType = (AbstractExprRelDataType<?>) fieldType;

core/src/main/java/org/opensearch/sql/calcite/utils/PPLOperandTypes.java

@@ -134,6 +134,65 @@ private PPLOperandTypes() {}
               SqlTypeFamily.NUMERIC,
               SqlTypeFamily.NUMERIC,
               SqlTypeFamily.NUMERIC));
+
+  public static final UDFOperandMetadata WIDTH_BUCKET_OPERAND =
+      UDFOperandMetadata.wrap(
+          (CompositeOperandTypeChecker)
+              // 1. Numeric fields: bin age span=10
+              OperandTypes.family(
+                      SqlTypeFamily.NUMERIC,
+                      SqlTypeFamily.INTEGER,
+                      SqlTypeFamily.NUMERIC,
+                      SqlTypeFamily.NUMERIC)
+                  // 2. Timestamp fields with OpenSearch type system
+                  // Used in: Production + Integration tests (CalciteBinCommandIT)
+                  .or(
+                      OperandTypes.family(
+                          SqlTypeFamily.TIMESTAMP,
+                          SqlTypeFamily.INTEGER,
+                          SqlTypeFamily.CHARACTER, // TIMESTAMP - TIMESTAMP = INTERVAL (as STRING)
+                          SqlTypeFamily.TIMESTAMP))
+                  // 3. Timestamp fields with Calcite SCOTT schema
+                  // Used in: Unit tests (CalcitePPLBinTest)
+                  .or(
+                      OperandTypes.family(
+                          SqlTypeFamily.TIMESTAMP,
+                          SqlTypeFamily.INTEGER,
+                          SqlTypeFamily.TIMESTAMP, // TIMESTAMP - TIMESTAMP = TIMESTAMP
+                          SqlTypeFamily.TIMESTAMP))
+                  // DATE field with OpenSearch type system
+                  // Used in: Production + Integration tests (CalciteBinCommandIT)
+                  .or(
+                      OperandTypes.family(
+                          SqlTypeFamily.DATE,
+                          SqlTypeFamily.INTEGER,
+                          SqlTypeFamily.CHARACTER, // DATE - DATE = INTERVAL (as STRING)
+                          SqlTypeFamily.DATE))
+                  // DATE field with Calcite SCOTT schema
+                  // Used in: Unit tests (CalcitePPLBinTest)
+                  .or(
+                      OperandTypes.family(
+                          SqlTypeFamily.DATE,
+                          SqlTypeFamily.INTEGER,
+                          SqlTypeFamily.DATE, // DATE - DATE = DATE
+                          SqlTypeFamily.DATE))
+                  // TIME field with OpenSearch type system
+                  // Used in: Production + Integration tests (CalciteBinCommandIT)
+                  .or(
+                      OperandTypes.family(
+                          SqlTypeFamily.TIME,
+                          SqlTypeFamily.INTEGER,
+                          SqlTypeFamily.CHARACTER, // TIME - TIME = INTERVAL (as STRING)
+                          SqlTypeFamily.TIME))
+                  // TIME field with Calcite SCOTT schema
+                  // Used in: Unit tests (CalcitePPLBinTest)
+                  .or(
+                      OperandTypes.family(
+                          SqlTypeFamily.TIME,
+                          SqlTypeFamily.INTEGER,
+                          SqlTypeFamily.TIME, // TIME - TIME = TIME
+                          SqlTypeFamily.TIME)));
+
   public static final UDFOperandMetadata NUMERIC_NUMERIC_NUMERIC_NUMERIC_NUMERIC =
       UDFOperandMetadata.wrap(
           OperandTypes.family(

core/src/main/java/org/opensearch/sql/calcite/utils/binning/BinnableField.java

@@ -11,13 +11,7 @@
 import org.opensearch.sql.calcite.utils.OpenSearchTypeFactory;
 import org.opensearch.sql.exception.SemanticCheckException;
 
-/**
- * Represents a validated field that supports binning operations. The existence of this class
- * guarantees that validation has been run - the field is either numeric or time-based.
- *
- * <p>This design encodes validation in the type system, preventing downstream code from forgetting
- * to validate or running validation multiple times.
- */
+/** Represents a field that supports binning operations. */
 @Getter
 public class BinnableField {
   private final RexNode fieldExpr;
@@ -27,13 +21,12 @@ public class BinnableField {
   private final boolean isNumeric;
 
   /**
-   * Creates a validated BinnableField. Throws SemanticCheckException if the field is neither
-   * numeric nor time-based.
+   * Creates a BinnableField. Validates that the field type is compatible with binning operations.
    *
    * @param fieldExpr The Rex expression for the field
    * @param fieldType The relational data type of the field
    * @param fieldName The name of the field (for error messages)
-   * @throws SemanticCheckException if the field is neither numeric nor time-based
+   * @throws SemanticCheckException if the field type is not supported for binning
    */
   public BinnableField(RexNode fieldExpr, RelDataType fieldType, String fieldName) {
     this.fieldExpr = fieldExpr;
@@ -43,13 +36,10 @@ public BinnableField(RexNode fieldExpr, RelDataType fieldType, String fieldName)
     this.isTimeBased = OpenSearchTypeFactory.isTimeBasedType(fieldType);
     this.isNumeric = OpenSearchTypeFactory.isNumericType(fieldType);
 
-    // Validation: field must be either numeric or time-based
+    // Reject truly unsupported types (e.g., BOOLEAN, ARRAY, MAP)
     if (!isNumeric && !isTimeBased) {
       throw new SemanticCheckException(
-          String.format(
-              "Cannot apply binning: field '%s' is non-numeric and not time-related, expected"
-                  + " numeric or time-related type",
-              fieldName));
+          String.format("Cannot apply binning to field '%s': unsupported type", fieldName));
     }
   }