You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@datafusion.apache.org by gi...@apache.org on 2026/10/08 00:45:31 UTC
(datafusion-comet) branch asf-site updated: Publish built docs triggered by f80042f78715e5a009352f1582f6c246a5f96131
This is an automated email from the ASF dual-hosted git repository.
github-actions[bot] pushed a commit to branch asf-site
in repository https://gitbox.apache.org/repos/asf/datafusion-comet.git
The following commit(s) were added to refs/heads/asf-site by this push:
new 9e796dc13f Publish built docs triggered by f80042f78715e5a009352f1582f6c246a5f96131
9e796dc13f is described below
commit 9e796dc13fe70eea026af6c47c3d2994b6cd653e
Author: github-actions[bot] <gi...@users.noreply.github.com>
AuthorDate: Thu Oct 8 00:45:26 2026 +0000
Publish built docs triggered by f80042f78715e5a009352f1582f6c246a5f96131
---
.../mermaid-f5b40459e5fe9b892b845c9198fe1c9420e05d14.svg | 2 +-
.../latest/compatibility/expressions/spark-3.4/array.md.txt | 11 ++++++++++-
.../latest/compatibility/expressions/spark-3.5/array.md.txt | 11 ++++++++++-
.../latest/compatibility/expressions/spark-4.0/array.md.txt | 11 ++++++++++-
.../latest/compatibility/expressions/spark-4.1/array.md.txt | 11 ++++++++++-
.../latest/compatibility/expressions/spark-4.2/array.md.txt | 11 ++++++++++-
_sources/user-guide/latest/expressions.md.txt | 8 ++++----
searchindex.js | 2 +-
.../latest/compatibility/expressions/spark-3.4/array.html | 13 ++++++++++++-
.../latest/compatibility/expressions/spark-3.5/array.html | 13 ++++++++++++-
.../latest/compatibility/expressions/spark-4.0/array.html | 13 ++++++++++++-
.../latest/compatibility/expressions/spark-4.1/array.html | 13 ++++++++++++-
.../latest/compatibility/expressions/spark-4.2/array.html | 13 ++++++++++++-
user-guide/latest/expressions.html | 10 +++++-----
14 files changed, 121 insertions(+), 21 deletions(-)
diff --git a/_images/mermaid-f5b40459e5fe9b892b845c9198fe1c9420e05d14.svg b/_images/mermaid-f5b40459e5fe9b892b845c9198fe1c9420e05d14.svg
index f1b72d43ea..142ac51173 100644
--- a/_images/mermaid-f5b40459e5fe9b892b845c9198fe1c9420e05d14.svg
+++ b/_images/mermaid-f5b40459e5fe9b892b845c9198fe1c9420e05d14.svg
@@ -1 +1 @@
-<svg id="my-svg" width="100%" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" class="flowchart" style="max-width: 511.73px; background-color: transparent;" viewBox="0 0 511.7299499511719 966" role="graphics-document document" aria-roledescription="flowchart-v2"><style>#my-svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#my-svg [...]
\ No newline at end of file
+<svg id="my-svg" width="100%" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" class="flowchart" style="max-width: 511.73px; background-color: transparent;" viewBox="0 0 511.7299499511719 966" role="graphics-document document" aria-roledescription="flowchart-v2"><style>#my-svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#my-svg [...]
\ No newline at end of file
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-3.4/array.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-3.4/array.md.txt
index b420be0b60..a1125a710c 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-3.4/array.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-3.4/array.md.txt
@@ -23,15 +23,17 @@ under the License.
## ArrayContains
-By default, `ArrayContains` is evaluated in the JVM using Spark's own code-generated implementation (run inside the Comet pipeline), which matches Spark exactly. Set `spark.comet.expression.ArrayContains.allowIncompatible=true` to opt into Comet's native implementation instead, which has the following differences from Spark:
+For applicable cases that are not selected for native execution automatically, `ArrayContains` is evaluated in the JVM using Spark's own code-generated implementation (run inside the Comet pipeline) by default. Set `spark.comet.expression.ArrayContains.allowIncompatible=true` to explicitly select Comet's native implementation, which has the following differences from Spark:
- Spark compares array elements with ordering.equiv, so -0.0 matches +0.0 and all NaNs match each other; Comet's native array_contains compares the raw Arrow values bitwise
+- Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet's native array_contains compares raw bytes
## ArrayDistinct
The following incompatibilities cause `ArrayDistinct` to fall back to Spark by default. Set `spark.comet.expression.ArrayDistinct.allowIncompatible=true` to enable Comet acceleration despite these differences.
- Floating-point elements match Spark's signed-zero and NaN semantics natively only on Spark 4.2.0, whose optimizer normalizes the arguments (SPARK-54918)
+- Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet's native array_distinct compares raw bytes
## ArrayExcept
@@ -70,6 +72,13 @@ For applicable cases that are not selected for native execution automatically, `
The following incompatibilities cause `ArrayUnion` to fall back to Spark by default. Set `spark.comet.expression.ArrayUnion.allowIncompatible=true` to enable Comet acceleration despite these differences.
- Floating-point elements match Spark's signed-zero and NaN semantics natively only on Spark 4.2.0, whose optimizer normalizes the arguments (SPARK-54918)
+- Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet's native array_union compares raw bytes
+
+## ArraysOverlap
+
+For applicable cases that are not selected for native execution automatically, `ArraysOverlap` is evaluated in the JVM using Spark's own code-generated implementation (run inside the Comet pipeline) by default. Set `spark.comet.expression.ArraysOverlap.allowIncompatible=true` to explicitly select Comet's native implementation, which has the following differences from Spark:
+
+- Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet's native arrays_overlap compares raw bytes
## ArraysZip
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-3.5/array.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-3.5/array.md.txt
index b420be0b60..a1125a710c 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-3.5/array.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-3.5/array.md.txt
@@ -23,15 +23,17 @@ under the License.
## ArrayContains
-By default, `ArrayContains` is evaluated in the JVM using Spark's own code-generated implementation (run inside the Comet pipeline), which matches Spark exactly. Set `spark.comet.expression.ArrayContains.allowIncompatible=true` to opt into Comet's native implementation instead, which has the following differences from Spark:
+For applicable cases that are not selected for native execution automatically, `ArrayContains` is evaluated in the JVM using Spark's own code-generated implementation (run inside the Comet pipeline) by default. Set `spark.comet.expression.ArrayContains.allowIncompatible=true` to explicitly select Comet's native implementation, which has the following differences from Spark:
- Spark compares array elements with ordering.equiv, so -0.0 matches +0.0 and all NaNs match each other; Comet's native array_contains compares the raw Arrow values bitwise
+- Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet's native array_contains compares raw bytes
## ArrayDistinct
The following incompatibilities cause `ArrayDistinct` to fall back to Spark by default. Set `spark.comet.expression.ArrayDistinct.allowIncompatible=true` to enable Comet acceleration despite these differences.
- Floating-point elements match Spark's signed-zero and NaN semantics natively only on Spark 4.2.0, whose optimizer normalizes the arguments (SPARK-54918)
+- Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet's native array_distinct compares raw bytes
## ArrayExcept
@@ -70,6 +72,13 @@ For applicable cases that are not selected for native execution automatically, `
The following incompatibilities cause `ArrayUnion` to fall back to Spark by default. Set `spark.comet.expression.ArrayUnion.allowIncompatible=true` to enable Comet acceleration despite these differences.
- Floating-point elements match Spark's signed-zero and NaN semantics natively only on Spark 4.2.0, whose optimizer normalizes the arguments (SPARK-54918)
+- Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet's native array_union compares raw bytes
+
+## ArraysOverlap
+
+For applicable cases that are not selected for native execution automatically, `ArraysOverlap` is evaluated in the JVM using Spark's own code-generated implementation (run inside the Comet pipeline) by default. Set `spark.comet.expression.ArraysOverlap.allowIncompatible=true` to explicitly select Comet's native implementation, which has the following differences from Spark:
+
+- Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet's native arrays_overlap compares raw bytes
## ArraysZip
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-4.0/array.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-4.0/array.md.txt
index b420be0b60..a1125a710c 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-4.0/array.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-4.0/array.md.txt
@@ -23,15 +23,17 @@ under the License.
## ArrayContains
-By default, `ArrayContains` is evaluated in the JVM using Spark's own code-generated implementation (run inside the Comet pipeline), which matches Spark exactly. Set `spark.comet.expression.ArrayContains.allowIncompatible=true` to opt into Comet's native implementation instead, which has the following differences from Spark:
+For applicable cases that are not selected for native execution automatically, `ArrayContains` is evaluated in the JVM using Spark's own code-generated implementation (run inside the Comet pipeline) by default. Set `spark.comet.expression.ArrayContains.allowIncompatible=true` to explicitly select Comet's native implementation, which has the following differences from Spark:
- Spark compares array elements with ordering.equiv, so -0.0 matches +0.0 and all NaNs match each other; Comet's native array_contains compares the raw Arrow values bitwise
+- Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet's native array_contains compares raw bytes
## ArrayDistinct
The following incompatibilities cause `ArrayDistinct` to fall back to Spark by default. Set `spark.comet.expression.ArrayDistinct.allowIncompatible=true` to enable Comet acceleration despite these differences.
- Floating-point elements match Spark's signed-zero and NaN semantics natively only on Spark 4.2.0, whose optimizer normalizes the arguments (SPARK-54918)
+- Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet's native array_distinct compares raw bytes
## ArrayExcept
@@ -70,6 +72,13 @@ For applicable cases that are not selected for native execution automatically, `
The following incompatibilities cause `ArrayUnion` to fall back to Spark by default. Set `spark.comet.expression.ArrayUnion.allowIncompatible=true` to enable Comet acceleration despite these differences.
- Floating-point elements match Spark's signed-zero and NaN semantics natively only on Spark 4.2.0, whose optimizer normalizes the arguments (SPARK-54918)
+- Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet's native array_union compares raw bytes
+
+## ArraysOverlap
+
+For applicable cases that are not selected for native execution automatically, `ArraysOverlap` is evaluated in the JVM using Spark's own code-generated implementation (run inside the Comet pipeline) by default. Set `spark.comet.expression.ArraysOverlap.allowIncompatible=true` to explicitly select Comet's native implementation, which has the following differences from Spark:
+
+- Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet's native arrays_overlap compares raw bytes
## ArraysZip
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-4.1/array.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-4.1/array.md.txt
index b420be0b60..a1125a710c 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-4.1/array.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-4.1/array.md.txt
@@ -23,15 +23,17 @@ under the License.
## ArrayContains
-By default, `ArrayContains` is evaluated in the JVM using Spark's own code-generated implementation (run inside the Comet pipeline), which matches Spark exactly. Set `spark.comet.expression.ArrayContains.allowIncompatible=true` to opt into Comet's native implementation instead, which has the following differences from Spark:
+For applicable cases that are not selected for native execution automatically, `ArrayContains` is evaluated in the JVM using Spark's own code-generated implementation (run inside the Comet pipeline) by default. Set `spark.comet.expression.ArrayContains.allowIncompatible=true` to explicitly select Comet's native implementation, which has the following differences from Spark:
- Spark compares array elements with ordering.equiv, so -0.0 matches +0.0 and all NaNs match each other; Comet's native array_contains compares the raw Arrow values bitwise
+- Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet's native array_contains compares raw bytes
## ArrayDistinct
The following incompatibilities cause `ArrayDistinct` to fall back to Spark by default. Set `spark.comet.expression.ArrayDistinct.allowIncompatible=true` to enable Comet acceleration despite these differences.
- Floating-point elements match Spark's signed-zero and NaN semantics natively only on Spark 4.2.0, whose optimizer normalizes the arguments (SPARK-54918)
+- Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet's native array_distinct compares raw bytes
## ArrayExcept
@@ -70,6 +72,13 @@ For applicable cases that are not selected for native execution automatically, `
The following incompatibilities cause `ArrayUnion` to fall back to Spark by default. Set `spark.comet.expression.ArrayUnion.allowIncompatible=true` to enable Comet acceleration despite these differences.
- Floating-point elements match Spark's signed-zero and NaN semantics natively only on Spark 4.2.0, whose optimizer normalizes the arguments (SPARK-54918)
+- Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet's native array_union compares raw bytes
+
+## ArraysOverlap
+
+For applicable cases that are not selected for native execution automatically, `ArraysOverlap` is evaluated in the JVM using Spark's own code-generated implementation (run inside the Comet pipeline) by default. Set `spark.comet.expression.ArraysOverlap.allowIncompatible=true` to explicitly select Comet's native implementation, which has the following differences from Spark:
+
+- Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet's native arrays_overlap compares raw bytes
## ArraysZip
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-4.2/array.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-4.2/array.md.txt
index b420be0b60..a1125a710c 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-4.2/array.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-4.2/array.md.txt
@@ -23,15 +23,17 @@ under the License.
## ArrayContains
-By default, `ArrayContains` is evaluated in the JVM using Spark's own code-generated implementation (run inside the Comet pipeline), which matches Spark exactly. Set `spark.comet.expression.ArrayContains.allowIncompatible=true` to opt into Comet's native implementation instead, which has the following differences from Spark:
+For applicable cases that are not selected for native execution automatically, `ArrayContains` is evaluated in the JVM using Spark's own code-generated implementation (run inside the Comet pipeline) by default. Set `spark.comet.expression.ArrayContains.allowIncompatible=true` to explicitly select Comet's native implementation, which has the following differences from Spark:
- Spark compares array elements with ordering.equiv, so -0.0 matches +0.0 and all NaNs match each other; Comet's native array_contains compares the raw Arrow values bitwise
+- Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet's native array_contains compares raw bytes
## ArrayDistinct
The following incompatibilities cause `ArrayDistinct` to fall back to Spark by default. Set `spark.comet.expression.ArrayDistinct.allowIncompatible=true` to enable Comet acceleration despite these differences.
- Floating-point elements match Spark's signed-zero and NaN semantics natively only on Spark 4.2.0, whose optimizer normalizes the arguments (SPARK-54918)
+- Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet's native array_distinct compares raw bytes
## ArrayExcept
@@ -70,6 +72,13 @@ For applicable cases that are not selected for native execution automatically, `
The following incompatibilities cause `ArrayUnion` to fall back to Spark by default. Set `spark.comet.expression.ArrayUnion.allowIncompatible=true` to enable Comet acceleration despite these differences.
- Floating-point elements match Spark's signed-zero and NaN semantics natively only on Spark 4.2.0, whose optimizer normalizes the arguments (SPARK-54918)
+- Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet's native array_union compares raw bytes
+
+## ArraysOverlap
+
+For applicable cases that are not selected for native execution automatically, `ArraysOverlap` is evaluated in the JVM using Spark's own code-generated implementation (run inside the Comet pipeline) by default. Set `spark.comet.expression.ArraysOverlap.allowIncompatible=true` to explicitly select Comet's native implementation, which has the following differences from Spark:
+
+- Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet's native arrays_overlap compares raw bytes
## ArraysZip
diff --git a/_sources/user-guide/latest/expressions.md.txt b/_sources/user-guide/latest/expressions.md.txt
index 28e5cdc4a9..e7072fec96 100644
--- a/_sources/user-guide/latest/expressions.md.txt
+++ b/_sources/user-guide/latest/expressions.md.txt
@@ -155,8 +155,8 @@ The tables below list every Spark built-in expression with its current status.
| `array` | ✅ | Native | |
| `array_append` | ✅ | Native | |
| `array_compact` | ✅ | — | |
-| `array_contains` | ✅ | Hybrid | Float/double element arrays route through the JVM codegen dispatcher by default; the native path is opt-in via allowIncompatible |
-| `array_distinct` | ✅ | Native | Floating-point elements fall back on Spark versions other than 4.2.0; signed-zero and NaN results may differ with native opt-in ([details](compatibility/floating-point.md)) |
+| `array_contains` | ✅ | Hybrid | Float/double element arrays and non-default string collations route through the JVM codegen dispatcher by default; the native path is opt-in via allowIncompatible |
+| `array_distinct` | ✅ | Native | Floating-point elements fall back on Spark versions other than 4.2.0; signed-zero and NaN results may differ with native opt-in ([details](compatibility/floating-point.md)). Non-default string collations fall back |
| `array_except` | ✅ | Hybrid | Routes through the JVM codegen dispatcher by default; the incompatible native path is opt-in via allowIncompatible ([details](compatibility/expressions/array.md)) |
| `array_insert` | ✅ | Native | |
| `array_intersect` | ✅ | Hybrid | Routes through the JVM codegen dispatcher by default; the incompatible native path is opt-in via allowIncompatible ([details](compatibility/expressions/array.md)) |
@@ -167,8 +167,8 @@ The tables below list every Spark built-in expression with its current status.
| `array_prepend` | ✅ | — | |
| `array_remove` | ✅ | Native | |
| `array_repeat` | ✅ | Native | |
-| `array_union` | ✅ | Native | Floating-point elements fall back on Spark versions other than 4.2.0; signed-zero and NaN results may differ with native opt-in ([details](compatibility/floating-point.md)) |
-| `arrays_overlap` | ✅ | Native | |
+| `array_union` | ✅ | Native | Floating-point elements fall back on Spark versions other than 4.2.0; signed-zero and NaN results may differ with native opt-in ([details](compatibility/floating-point.md)). Non-default string collations fall back |
+| `arrays_overlap` | ✅ | Hybrid | Non-default string collations use the JVM codegen dispatcher |
| `arrays_zip` | ✅ | Native | |
| `element_at` | ✅ | Native | |
| `flatten` | ✅ | Native | Binary/struct/map elements fall back |
diff --git a/searchindex.js b/searchindex.js
index 2540d88f7a..03085a6655 100644
--- a/searchindex.js
+++ b/searchindex.js
@@ -1 +1 @@
-Search.setIndex({"alltitles": {"!": [[58, "id1"]], "%": [[56, "id1"]], "&": [[46, "id1"]], "*": [[56, "id2"]], "+": [[56, "id3"]], "-": [[56, "id4"]], "/": [[56, "id5"]], "1. Format Your Code": [[43, "format-your-code"]], "1. Install Comet": [[65, "install-comet"], [77, "install-comet"]], "1. Native Operators (nativeExecs map)": [[29, "native-operators-nativeexecs-map"]], "2. Build and Verify": [[43, "build-and-verify"]], "2. Clone Iceberg and Apply Diff": [[65, "clone-iceberg-and-apply- [...]
\ No newline at end of file
+Search.setIndex({"alltitles": {"!": [[58, "id1"]], "%": [[56, "id1"]], "&": [[46, "id1"]], "*": [[56, "id2"]], "+": [[56, "id3"]], "-": [[56, "id4"]], "/": [[56, "id5"]], "1. Format Your Code": [[43, "format-your-code"]], "1. Install Comet": [[65, "install-comet"], [77, "install-comet"]], "1. Native Operators (nativeExecs map)": [[29, "native-operators-nativeexecs-map"]], "2. Build and Verify": [[43, "build-and-verify"]], "2. Clone Iceberg and Apply Diff": [[65, "clone-iceberg-and-apply- [...]
\ No newline at end of file
diff --git a/user-guide/latest/compatibility/expressions/spark-3.4/array.html b/user-guide/latest/compatibility/expressions/spark-3.4/array.html
index 4ddda5591a..3c65523e9b 100644
--- a/user-guide/latest/compatibility/expressions/spark-3.4/array.html
+++ b/user-guide/latest/compatibility/expressions/spark-3.4/array.html
@@ -854,9 +854,10 @@ under the License.
<!--BEGIN:EXPR_COMPAT[array]-->
<section id="arraycontains">
<h2>ArrayContains<a class="headerlink" href="#arraycontains" title="Link to this heading">#</a></h2>
-<p>By default, <code class="docutils literal notranslate"><span class="pre">ArrayContains</span></code> is evaluated in the JVM using Spark’s own code-generated implementation (run inside the Comet pipeline), which matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayContains.allowIncompatible=true</span></code> to opt into Comet’s native implementation instead, which has the following differences from Spark:</p>
+<p>For applicable cases that are not selected for native execution automatically, <code class="docutils literal notranslate"><span class="pre">ArrayContains</span></code> is evaluated in the JVM using Spark’s own code-generated implementation (run inside the Comet pipeline) by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayContains.allowIncompatible=true</span></code> to explicitly select Comet’s native implementation, which has the [...]
<ul class="simple">
<li><p>Spark compares array elements with ordering.equiv, so -0.0 matches +0.0 and all NaNs match each other; Comet’s native array_contains compares the raw Arrow values bitwise</p></li>
+<li><p>Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet’s native array_contains compares raw bytes</p></li>
</ul>
</section>
<section id="arraydistinct">
@@ -864,6 +865,7 @@ under the License.
<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">ArrayDistinct</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayDistinct.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
<ul class="simple">
<li><p>Floating-point elements match Spark’s signed-zero and NaN semantics natively only on Spark 4.2.0, whose optimizer normalizes the arguments (SPARK-54918)</p></li>
+<li><p>Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet’s native array_distinct compares raw bytes</p></li>
</ul>
</section>
<section id="arrayexcept">
@@ -908,6 +910,14 @@ under the License.
<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">ArrayUnion</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayUnion.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
<ul class="simple">
<li><p>Floating-point elements match Spark’s signed-zero and NaN semantics natively only on Spark 4.2.0, whose optimizer normalizes the arguments (SPARK-54918)</p></li>
+<li><p>Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet’s native array_union compares raw bytes</p></li>
+</ul>
+</section>
+<section id="arraysoverlap">
+<h2>ArraysOverlap<a class="headerlink" href="#arraysoverlap" title="Link to this heading">#</a></h2>
+<p>For applicable cases that are not selected for native execution automatically, <code class="docutils literal notranslate"><span class="pre">ArraysOverlap</span></code> is evaluated in the JVM using Spark’s own code-generated implementation (run inside the Comet pipeline) by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArraysOverlap.allowIncompatible=true</span></code> to explicitly select Comet’s native implementation, which has the [...]
+<ul class="simple">
+<li><p>Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet’s native arrays_overlap compares raw bytes</p></li>
</ul>
</section>
<section id="arrayszip">
@@ -990,6 +1000,7 @@ under the License.
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arraymax">ArrayMax</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arraymin">ArrayMin</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arrayunion">ArrayUnion</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arraysoverlap">ArraysOverlap</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arrayszip">ArraysZip</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#sequence">Sequence</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#shuffle">Shuffle</a></li>
diff --git a/user-guide/latest/compatibility/expressions/spark-3.5/array.html b/user-guide/latest/compatibility/expressions/spark-3.5/array.html
index 31214c402b..debe4631a4 100644
--- a/user-guide/latest/compatibility/expressions/spark-3.5/array.html
+++ b/user-guide/latest/compatibility/expressions/spark-3.5/array.html
@@ -854,9 +854,10 @@ under the License.
<!--BEGIN:EXPR_COMPAT[array]-->
<section id="arraycontains">
<h2>ArrayContains<a class="headerlink" href="#arraycontains" title="Link to this heading">#</a></h2>
-<p>By default, <code class="docutils literal notranslate"><span class="pre">ArrayContains</span></code> is evaluated in the JVM using Spark’s own code-generated implementation (run inside the Comet pipeline), which matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayContains.allowIncompatible=true</span></code> to opt into Comet’s native implementation instead, which has the following differences from Spark:</p>
+<p>For applicable cases that are not selected for native execution automatically, <code class="docutils literal notranslate"><span class="pre">ArrayContains</span></code> is evaluated in the JVM using Spark’s own code-generated implementation (run inside the Comet pipeline) by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayContains.allowIncompatible=true</span></code> to explicitly select Comet’s native implementation, which has the [...]
<ul class="simple">
<li><p>Spark compares array elements with ordering.equiv, so -0.0 matches +0.0 and all NaNs match each other; Comet’s native array_contains compares the raw Arrow values bitwise</p></li>
+<li><p>Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet’s native array_contains compares raw bytes</p></li>
</ul>
</section>
<section id="arraydistinct">
@@ -864,6 +865,7 @@ under the License.
<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">ArrayDistinct</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayDistinct.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
<ul class="simple">
<li><p>Floating-point elements match Spark’s signed-zero and NaN semantics natively only on Spark 4.2.0, whose optimizer normalizes the arguments (SPARK-54918)</p></li>
+<li><p>Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet’s native array_distinct compares raw bytes</p></li>
</ul>
</section>
<section id="arrayexcept">
@@ -908,6 +910,14 @@ under the License.
<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">ArrayUnion</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayUnion.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
<ul class="simple">
<li><p>Floating-point elements match Spark’s signed-zero and NaN semantics natively only on Spark 4.2.0, whose optimizer normalizes the arguments (SPARK-54918)</p></li>
+<li><p>Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet’s native array_union compares raw bytes</p></li>
+</ul>
+</section>
+<section id="arraysoverlap">
+<h2>ArraysOverlap<a class="headerlink" href="#arraysoverlap" title="Link to this heading">#</a></h2>
+<p>For applicable cases that are not selected for native execution automatically, <code class="docutils literal notranslate"><span class="pre">ArraysOverlap</span></code> is evaluated in the JVM using Spark’s own code-generated implementation (run inside the Comet pipeline) by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArraysOverlap.allowIncompatible=true</span></code> to explicitly select Comet’s native implementation, which has the [...]
+<ul class="simple">
+<li><p>Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet’s native arrays_overlap compares raw bytes</p></li>
</ul>
</section>
<section id="arrayszip">
@@ -990,6 +1000,7 @@ under the License.
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arraymax">ArrayMax</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arraymin">ArrayMin</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arrayunion">ArrayUnion</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arraysoverlap">ArraysOverlap</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arrayszip">ArraysZip</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#sequence">Sequence</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#shuffle">Shuffle</a></li>
diff --git a/user-guide/latest/compatibility/expressions/spark-4.0/array.html b/user-guide/latest/compatibility/expressions/spark-4.0/array.html
index 81f715af91..93b30ced5a 100644
--- a/user-guide/latest/compatibility/expressions/spark-4.0/array.html
+++ b/user-guide/latest/compatibility/expressions/spark-4.0/array.html
@@ -854,9 +854,10 @@ under the License.
<!--BEGIN:EXPR_COMPAT[array]-->
<section id="arraycontains">
<h2>ArrayContains<a class="headerlink" href="#arraycontains" title="Link to this heading">#</a></h2>
-<p>By default, <code class="docutils literal notranslate"><span class="pre">ArrayContains</span></code> is evaluated in the JVM using Spark’s own code-generated implementation (run inside the Comet pipeline), which matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayContains.allowIncompatible=true</span></code> to opt into Comet’s native implementation instead, which has the following differences from Spark:</p>
+<p>For applicable cases that are not selected for native execution automatically, <code class="docutils literal notranslate"><span class="pre">ArrayContains</span></code> is evaluated in the JVM using Spark’s own code-generated implementation (run inside the Comet pipeline) by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayContains.allowIncompatible=true</span></code> to explicitly select Comet’s native implementation, which has the [...]
<ul class="simple">
<li><p>Spark compares array elements with ordering.equiv, so -0.0 matches +0.0 and all NaNs match each other; Comet’s native array_contains compares the raw Arrow values bitwise</p></li>
+<li><p>Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet’s native array_contains compares raw bytes</p></li>
</ul>
</section>
<section id="arraydistinct">
@@ -864,6 +865,7 @@ under the License.
<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">ArrayDistinct</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayDistinct.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
<ul class="simple">
<li><p>Floating-point elements match Spark’s signed-zero and NaN semantics natively only on Spark 4.2.0, whose optimizer normalizes the arguments (SPARK-54918)</p></li>
+<li><p>Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet’s native array_distinct compares raw bytes</p></li>
</ul>
</section>
<section id="arrayexcept">
@@ -908,6 +910,14 @@ under the License.
<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">ArrayUnion</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayUnion.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
<ul class="simple">
<li><p>Floating-point elements match Spark’s signed-zero and NaN semantics natively only on Spark 4.2.0, whose optimizer normalizes the arguments (SPARK-54918)</p></li>
+<li><p>Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet’s native array_union compares raw bytes</p></li>
+</ul>
+</section>
+<section id="arraysoverlap">
+<h2>ArraysOverlap<a class="headerlink" href="#arraysoverlap" title="Link to this heading">#</a></h2>
+<p>For applicable cases that are not selected for native execution automatically, <code class="docutils literal notranslate"><span class="pre">ArraysOverlap</span></code> is evaluated in the JVM using Spark’s own code-generated implementation (run inside the Comet pipeline) by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArraysOverlap.allowIncompatible=true</span></code> to explicitly select Comet’s native implementation, which has the [...]
+<ul class="simple">
+<li><p>Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet’s native arrays_overlap compares raw bytes</p></li>
</ul>
</section>
<section id="arrayszip">
@@ -990,6 +1000,7 @@ under the License.
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arraymax">ArrayMax</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arraymin">ArrayMin</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arrayunion">ArrayUnion</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arraysoverlap">ArraysOverlap</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arrayszip">ArraysZip</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#sequence">Sequence</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#shuffle">Shuffle</a></li>
diff --git a/user-guide/latest/compatibility/expressions/spark-4.1/array.html b/user-guide/latest/compatibility/expressions/spark-4.1/array.html
index fa6dc82379..d2d28463a2 100644
--- a/user-guide/latest/compatibility/expressions/spark-4.1/array.html
+++ b/user-guide/latest/compatibility/expressions/spark-4.1/array.html
@@ -854,9 +854,10 @@ under the License.
<!--BEGIN:EXPR_COMPAT[array]-->
<section id="arraycontains">
<h2>ArrayContains<a class="headerlink" href="#arraycontains" title="Link to this heading">#</a></h2>
-<p>By default, <code class="docutils literal notranslate"><span class="pre">ArrayContains</span></code> is evaluated in the JVM using Spark’s own code-generated implementation (run inside the Comet pipeline), which matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayContains.allowIncompatible=true</span></code> to opt into Comet’s native implementation instead, which has the following differences from Spark:</p>
+<p>For applicable cases that are not selected for native execution automatically, <code class="docutils literal notranslate"><span class="pre">ArrayContains</span></code> is evaluated in the JVM using Spark’s own code-generated implementation (run inside the Comet pipeline) by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayContains.allowIncompatible=true</span></code> to explicitly select Comet’s native implementation, which has the [...]
<ul class="simple">
<li><p>Spark compares array elements with ordering.equiv, so -0.0 matches +0.0 and all NaNs match each other; Comet’s native array_contains compares the raw Arrow values bitwise</p></li>
+<li><p>Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet’s native array_contains compares raw bytes</p></li>
</ul>
</section>
<section id="arraydistinct">
@@ -864,6 +865,7 @@ under the License.
<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">ArrayDistinct</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayDistinct.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
<ul class="simple">
<li><p>Floating-point elements match Spark’s signed-zero and NaN semantics natively only on Spark 4.2.0, whose optimizer normalizes the arguments (SPARK-54918)</p></li>
+<li><p>Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet’s native array_distinct compares raw bytes</p></li>
</ul>
</section>
<section id="arrayexcept">
@@ -908,6 +910,14 @@ under the License.
<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">ArrayUnion</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayUnion.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
<ul class="simple">
<li><p>Floating-point elements match Spark’s signed-zero and NaN semantics natively only on Spark 4.2.0, whose optimizer normalizes the arguments (SPARK-54918)</p></li>
+<li><p>Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet’s native array_union compares raw bytes</p></li>
+</ul>
+</section>
+<section id="arraysoverlap">
+<h2>ArraysOverlap<a class="headerlink" href="#arraysoverlap" title="Link to this heading">#</a></h2>
+<p>For applicable cases that are not selected for native execution automatically, <code class="docutils literal notranslate"><span class="pre">ArraysOverlap</span></code> is evaluated in the JVM using Spark’s own code-generated implementation (run inside the Comet pipeline) by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArraysOverlap.allowIncompatible=true</span></code> to explicitly select Comet’s native implementation, which has the [...]
+<ul class="simple">
+<li><p>Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet’s native arrays_overlap compares raw bytes</p></li>
</ul>
</section>
<section id="arrayszip">
@@ -990,6 +1000,7 @@ under the License.
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arraymax">ArrayMax</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arraymin">ArrayMin</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arrayunion">ArrayUnion</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arraysoverlap">ArraysOverlap</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arrayszip">ArraysZip</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#sequence">Sequence</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#shuffle">Shuffle</a></li>
diff --git a/user-guide/latest/compatibility/expressions/spark-4.2/array.html b/user-guide/latest/compatibility/expressions/spark-4.2/array.html
index 3c975d9a8a..6b4c0701e7 100644
--- a/user-guide/latest/compatibility/expressions/spark-4.2/array.html
+++ b/user-guide/latest/compatibility/expressions/spark-4.2/array.html
@@ -854,9 +854,10 @@ under the License.
<!--BEGIN:EXPR_COMPAT[array]-->
<section id="arraycontains">
<h2>ArrayContains<a class="headerlink" href="#arraycontains" title="Link to this heading">#</a></h2>
-<p>By default, <code class="docutils literal notranslate"><span class="pre">ArrayContains</span></code> is evaluated in the JVM using Spark’s own code-generated implementation (run inside the Comet pipeline), which matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayContains.allowIncompatible=true</span></code> to opt into Comet’s native implementation instead, which has the following differences from Spark:</p>
+<p>For applicable cases that are not selected for native execution automatically, <code class="docutils literal notranslate"><span class="pre">ArrayContains</span></code> is evaluated in the JVM using Spark’s own code-generated implementation (run inside the Comet pipeline) by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayContains.allowIncompatible=true</span></code> to explicitly select Comet’s native implementation, which has the [...]
<ul class="simple">
<li><p>Spark compares array elements with ordering.equiv, so -0.0 matches +0.0 and all NaNs match each other; Comet’s native array_contains compares the raw Arrow values bitwise</p></li>
+<li><p>Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet’s native array_contains compares raw bytes</p></li>
</ul>
</section>
<section id="arraydistinct">
@@ -864,6 +865,7 @@ under the License.
<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">ArrayDistinct</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayDistinct.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
<ul class="simple">
<li><p>Floating-point elements match Spark’s signed-zero and NaN semantics natively only on Spark 4.2.0, whose optimizer normalizes the arguments (SPARK-54918)</p></li>
+<li><p>Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet’s native array_distinct compares raw bytes</p></li>
</ul>
</section>
<section id="arrayexcept">
@@ -908,6 +910,14 @@ under the License.
<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">ArrayUnion</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayUnion.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
<ul class="simple">
<li><p>Floating-point elements match Spark’s signed-zero and NaN semantics natively only on Spark 4.2.0, whose optimizer normalizes the arguments (SPARK-54918)</p></li>
+<li><p>Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet’s native array_union compares raw bytes</p></li>
+</ul>
+</section>
+<section id="arraysoverlap">
+<h2>ArraysOverlap<a class="headerlink" href="#arraysoverlap" title="Link to this heading">#</a></h2>
+<p>For applicable cases that are not selected for native execution automatically, <code class="docutils literal notranslate"><span class="pre">ArraysOverlap</span></code> is evaluated in the JVM using Spark’s own code-generated implementation (run inside the Comet pipeline) by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArraysOverlap.allowIncompatible=true</span></code> to explicitly select Comet’s native implementation, which has the [...]
+<ul class="simple">
+<li><p>Spark compares non-UTF8_BINARY collated string elements under their collation, while Comet’s native arrays_overlap compares raw bytes</p></li>
</ul>
</section>
<section id="arrayszip">
@@ -990,6 +1000,7 @@ under the License.
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arraymax">ArrayMax</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arraymin">ArrayMin</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arrayunion">ArrayUnion</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arraysoverlap">ArraysOverlap</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#arrayszip">ArraysZip</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#sequence">Sequence</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#shuffle">Shuffle</a></li>
diff --git a/user-guide/latest/expressions.html b/user-guide/latest/expressions.html
index 698778fed3..89b913e58e 100644
--- a/user-guide/latest/expressions.html
+++ b/user-guide/latest/expressions.html
@@ -1279,12 +1279,12 @@ expressions. The following function families are <strong>not currently planned</
<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">array_contains</span></code></p></td>
<td><p>✅</p></td>
<td><p>Hybrid</p></td>
-<td><p>Float/double element arrays route through the JVM codegen dispatcher by default; the native path is opt-in via allowIncompatible</p></td>
+<td><p>Float/double element arrays and non-default string collations route through the JVM codegen dispatcher by default; the native path is opt-in via allowIncompatible</p></td>
</tr>
<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">array_distinct</span></code></p></td>
<td><p>✅</p></td>
<td><p>Native</p></td>
-<td><p>Floating-point elements fall back on Spark versions other than 4.2.0; signed-zero and NaN results may differ with native opt-in (<a class="reference internal" href="compatibility/floating-point.html"><span class="std std-doc">details</span></a>)</p></td>
+<td><p>Floating-point elements fall back on Spark versions other than 4.2.0; signed-zero and NaN results may differ with native opt-in (<a class="reference internal" href="compatibility/floating-point.html"><span class="std std-doc">details</span></a>). Non-default string collations fall back</p></td>
</tr>
<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">array_except</span></code></p></td>
<td><p>✅</p></td>
@@ -1339,12 +1339,12 @@ expressions. The following function families are <strong>not currently planned</
<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">array_union</span></code></p></td>
<td><p>✅</p></td>
<td><p>Native</p></td>
-<td><p>Floating-point elements fall back on Spark versions other than 4.2.0; signed-zero and NaN results may differ with native opt-in (<a class="reference internal" href="compatibility/floating-point.html"><span class="std std-doc">details</span></a>)</p></td>
+<td><p>Floating-point elements fall back on Spark versions other than 4.2.0; signed-zero and NaN results may differ with native opt-in (<a class="reference internal" href="compatibility/floating-point.html"><span class="std std-doc">details</span></a>). Non-default string collations fall back</p></td>
</tr>
<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">arrays_overlap</span></code></p></td>
<td><p>✅</p></td>
-<td><p>Native</p></td>
-<td><p></p></td>
+<td><p>Hybrid</p></td>
+<td><p>Non-default string collations use the JVM codegen dispatcher</p></td>
</tr>
<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">arrays_zip</span></code></p></td>
<td><p>✅</p></td>
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datafusion.apache.org
For additional commands, e-mail: commits-help@datafusion.apache.org