Register LENGTH, REGEXP_REPLACE, DATE_TRUNC in unified function spec

[dai-chen]

Description

Register LENGTH, REGEXP_REPLACE, and DATE_TRUNC in the unified function spec, unblocking ClickBench q28, q29, and q43 at the unified SQL parsing/validation layer. Additionally, a preCompilationRules() extension point enables late-binding function implementations (e.g., DATE_TRUNC → FLOOR) applied only at compilation time, keeping the logical plan clean for external consumers.

Note: These functions are safe to register: LENGTH and REGEXP_REPLACE have consistent signatures across all execution paths (SparkSQL, DataFusion, SQL V2, PPL), and DATE_TRUNC aligns with SparkSQL and DataFusion semantics with no conflicting definition in existing engines. See the criteria in #5346 (comment).

Related Issues

Part of #5248

Check List

• New functionality includes testing.
• New functionality has been documented.
• New functionality has javadoc added.
• New functionality has a user manual doc added.
• New PPL command checklist all confirmed.
• API changes companion pull request created.
• Commits are signed per the DCO using --signoff or -s.
• Public documentation issue/PR created.

By submitting this pull request, I confirm that my contribution is made under the terms of the Apache 2.0 license.
For more information on following Developer Certificate of Origin and signing off your commits, please check here.

[github-actions]

PR Reviewer Guide 🔍

Here are some key observations to aid the review process:

🧪 PR contains tests

🔒 No security concerns identified

✅ No TODO sections

🔀 No multiple PR themes

⚡ Recommended focus areas for review Possible Issue The visit method creates a new RexBuilder from node.getCluster().getRexBuilder() but then applies the shuttle to visited instead of node. If the shuttle modifies the node structure, the RexBuilder may reference stale cluster metadata. This can cause inconsistencies when the rewritten expressions reference types or operators from a different cluster state. public RelNode visit(RelNode node) { RelNode visited = super.visit(node); RexBuilder rexBuilder = node.getCluster().getRexBuilder(); return visited.accept( new RexShuttle() { @Override public RexNode visitCall(RexCall call) { RexCall visited = (RexCall) super.visitCall(call); return Optional.ofNullable(bindings.get(visited.getOperator())) .map(impl -> impl.apply(rexBuilder, visited)) .orElse(visited); } }); Possible Issue The impl lambda for date_trunc casts call.operands.get(0) to RexLiteral without null or type checking. If the first operand is not a literal (e.g., a column reference or expression), this throws ClassCastException at compilation time. The function should either validate the operand type or handle non-literal cases gracefully. RexLiteral unitLiteral = (RexLiteral) call.operands.get(0); String unit = unitLiteral.getValueAs(String.class);

[github-actions]

PR Code Suggestions ✨

Explore these optional code suggestions:

Category	Suggestion	Impact
Possible issue	Handle potential duplicate operator keys The Collectors.toMap will throw IllegalStateException if duplicate keys (operators) exist. Since multiple function specs could theoretically share the same operator, use toMap with a merge function to handle collisions explicitly, or validate uniqueness upfront. api/src/main/java/org/opensearch/sql/api/spec/core/LateBindingFunctionRule.java [28-32] private final Map<SqlOperator, BiFunction<RexBuilder, RexCall, RexNode>> bindings = UnifiedFunctionSpec.ALL_SPECS.values().stream() .filter(spec -> spec.getImpl() != null) .collect( - Collectors.toMap(UnifiedFunctionSpec::getOperator, UnifiedFunctionSpec::getImpl)); + Collectors.toMap( + UnifiedFunctionSpec::getOperator, + UnifiedFunctionSpec::getImpl, + (existing, replacement) -> existing)); Suggestion importance[1-10]: 7 __ Why: The suggestion correctly identifies that Collectors.toMap throws IllegalStateException on duplicate keys. Adding a merge function prevents runtime exceptions if multiple UnifiedFunctionSpec instances share the same SqlOperator. This is a valid defensive programming practice that improves robustness.	Medium