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/09/18 20:20:38 UTC
(datafusion-comet) branch asf-site updated: Publish built docs triggered by c56cef77a973af89255553b0ac08a98385409e67
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 9d9c690076 Publish built docs triggered by c56cef77a973af89255553b0ac08a98385409e67
9d9c690076 is described below
commit 9d9c6900763f65e80216a65d9ba46412d6c2b3fe
Author: github-actions[bot] <gi...@users.noreply.github.com>
AuthorDate: Fri Sep 18 20:20:34 2026 +0000
Publish built docs triggered by c56cef77a973af89255553b0ac08a98385409e67
---
.../compatibility/expressions/spark-3.4/misc.md.txt | 2 +-
.../compatibility/expressions/spark-3.5/misc.md.txt | 2 +-
.../compatibility/expressions/spark-4.0/misc.md.txt | 2 +-
.../compatibility/expressions/spark-4.1/misc.md.txt | 2 +-
.../latest/compatibility/floating-point.md.txt | 8 +++++---
_sources/user-guide/latest/configs.md.txt | 2 +-
_sources/user-guide/latest/tuning.md.txt | 17 ++++++++++++++---
searchindex.js | 2 +-
.../compatibility/expressions/spark-3.4/misc.html | 2 +-
.../compatibility/expressions/spark-3.5/misc.html | 2 +-
.../compatibility/expressions/spark-4.0/misc.html | 2 +-
.../compatibility/expressions/spark-4.1/misc.html | 2 +-
user-guide/latest/compatibility/floating-point.html | 8 +++++---
user-guide/latest/configs.html | 2 +-
user-guide/latest/tuning.html | 15 ++++++++++++---
15 files changed, 47 insertions(+), 23 deletions(-)
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-3.4/misc.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-3.4/misc.md.txt
index b9a6d05e52..b206e6aee3 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-3.4/misc.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-3.4/misc.md.txt
@@ -49,7 +49,7 @@ The following cases are not supported by Comet and always fall back to Spark, re
The following incompatibilities cause `SortOrder` to fall back to Spark by default. Set `spark.comet.expression.SortOrder.allowIncompatible=true` to enable Comet acceleration despite these differences.
-- When `spark.comet.exec.strictFloatingPoint=true`, sorting on floating-point types is not 100% compatible with Spark
+- Sorting on floating-point values nested in arrays, structs, or maps is not 100% compatible with Spark when `spark.comet.exec.strictFloatingPoint=true`
## StaticInvoke
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-3.5/misc.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-3.5/misc.md.txt
index 7c643ab030..876efc269d 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-3.5/misc.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-3.5/misc.md.txt
@@ -49,7 +49,7 @@ The following cases are not supported by Comet and always fall back to Spark, re
The following incompatibilities cause `SortOrder` to fall back to Spark by default. Set `spark.comet.expression.SortOrder.allowIncompatible=true` to enable Comet acceleration despite these differences.
-- When `spark.comet.exec.strictFloatingPoint=true`, sorting on floating-point types is not 100% compatible with Spark
+- Sorting on floating-point values nested in arrays, structs, or maps is not 100% compatible with Spark when `spark.comet.exec.strictFloatingPoint=true`
## StaticInvoke
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-4.0/misc.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-4.0/misc.md.txt
index 7c643ab030..876efc269d 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-4.0/misc.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-4.0/misc.md.txt
@@ -49,7 +49,7 @@ The following cases are not supported by Comet and always fall back to Spark, re
The following incompatibilities cause `SortOrder` to fall back to Spark by default. Set `spark.comet.expression.SortOrder.allowIncompatible=true` to enable Comet acceleration despite these differences.
-- When `spark.comet.exec.strictFloatingPoint=true`, sorting on floating-point types is not 100% compatible with Spark
+- Sorting on floating-point values nested in arrays, structs, or maps is not 100% compatible with Spark when `spark.comet.exec.strictFloatingPoint=true`
## StaticInvoke
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-4.1/misc.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-4.1/misc.md.txt
index 7c643ab030..876efc269d 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-4.1/misc.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-4.1/misc.md.txt
@@ -49,7 +49,7 @@ The following cases are not supported by Comet and always fall back to Spark, re
The following incompatibilities cause `SortOrder` to fall back to Spark by default. Set `spark.comet.expression.SortOrder.allowIncompatible=true` to enable Comet acceleration despite these differences.
-- When `spark.comet.exec.strictFloatingPoint=true`, sorting on floating-point types is not 100% compatible with Spark
+- Sorting on floating-point values nested in arrays, structs, or maps is not 100% compatible with Spark when `spark.comet.exec.strictFloatingPoint=true`
## StaticInvoke
diff --git a/_sources/user-guide/latest/compatibility/floating-point.md.txt b/_sources/user-guide/latest/compatibility/floating-point.md.txt
index b39ef7f645..6d3a3c112b 100644
--- a/_sources/user-guide/latest/compatibility/floating-point.md.txt
+++ b/_sources/user-guide/latest/compatibility/floating-point.md.txt
@@ -43,6 +43,8 @@ Native sorting of floating-point values nested in arrays or structs still uses A
ordering. Nested keys can therefore produce different ordering or rank results from Spark; see
[#5507](https://github.com/apache/datafusion-comet/issues/5507).
-The existing `spark.comet.exec.strictFloatingPoint=true` fallback policy is unchanged, including
-its conservative fallback for scalar floating-point sort keys. Narrowing that scalar-sort
-admission policy is tracked in [#5506](https://github.com/apache/datafusion-comet/issues/5506).
+Because those scalar comparison keys match Spark, `spark.comet.exec.strictFloatingPoint=true` no
+longer forces a fallback for them: scalar `FLOAT` and `DOUBLE` sort keys, window and rank order
+keys, and range partitioning keys all stay native under strict mode. Floating-point values nested
+in arrays, structs, or maps still fall back under strict mode, because their ordering is the raw
+total ordering described above.
diff --git a/_sources/user-guide/latest/configs.md.txt b/_sources/user-guide/latest/configs.md.txt
index 923646c3c1..57b3e5ba6d 100644
--- a/_sources/user-guide/latest/configs.md.txt
+++ b/_sources/user-guide/latest/configs.md.txt
@@ -65,7 +65,7 @@ Comet provides the following configuration settings.
| `spark.comet.exec.join.dynamicFilter.enabled` | Experimental opt-in: use a completed native hash join build's key domain to prune eligible native Parquet row groups and filter probe batches before the hash probe. Supports inner joins with one direct signed integer key and one native partition per input, including both Spark build sides. The probe filter remains active when reader pruning is unavailable. Unsupported joins retain their existing execution path. Filters do not cross Spark [...]
| `spark.comet.exec.pyarrowUDF.enabled` | Experimental: whether to enable optimized execution of PyArrow UDFs (mapInArrow/mapInPandas). When enabled, Comet passes Arrow columnar data directly to Python UDFs without the intermediate Arrow-to-Row-to-Arrow conversion that Spark normally performs. Disabled by default while the feature stabilizes. | false |
| `spark.comet.exec.scalaUDF.codegen.enabled` | Whether to route Spark `ScalaUDF` expressions through Comet's Arrow-direct codegen dispatcher. When enabled, a supported ScalaUDF is compiled into a per-batch kernel that reads and writes Arrow vectors directly from native execution. When disabled, plans containing a ScalaUDF fall back to Spark for the enclosing operator. The same dispatcher backs the regex family (`rlike`, `regexp_replace`, `split`, `regexp_extract`, `regexp_extract_all`, [...]
-| `spark.comet.exec.strictFloatingPoint` | When enabled, fall back to Spark for floating-point operations that may differ from Spark, such as when comparing or sorting -0.0 and 0.0. For more information, refer to the [Comet Compatibility Guide](https://datafusion.apache.org/comet/user-guide/latest/compatibility/index.html). | false |
+| `spark.comet.exec.strictFloatingPoint` | When enabled, fall back to Spark for floating-point operations that may differ from Spark, such as comparing -0.0 and 0.0, sorting floating-point values nested in arrays, structs, or maps, or sorting the elements of a floating-point array with `sort_array`. Scalar `ORDER BY`, window ordering and range partitioning keys are unaffected, because Comet normalizes those comparison keys to match Spark. For more information, refer to the [Comet Compati [...]
| `spark.comet.exec.transitionRevert.enabled` | When enabled, Comet reverts a query stage to Spark row-based execution if the number of columnar-to-row (C2R) transitions in the stage exceeds the configured threshold. This avoids the overhead of repeated format conversions in stages where many operators fall back to row-based execution. | false |
| `spark.comet.exec.transitionRevert.maxTransitions` | The maximum number of columnar-to-row (C2R) transitions allowed in a single query stage before Comet reverts the entire stage to Spark row-based execution. When columnar shuffle is enabled, each such C2R typically implies a corresponding row-to-columnar conversion to feed back into the columnar shuffle, so each counted C2R is a useful proxy for the conversion overhead in the stage. Set to 0 to revert any stage with transitions. Only [...]
| `spark.comet.metrics.enabled` | Whether to enable Comet metrics reporting through Spark's external monitoring system. When enabled, Comet exposes metrics such as native operators, Spark operators, queries planned, transitions, and acceleration ratio. These metrics can be visualized through tools like Grafana when a metrics sink (e.g., Prometheus) is configured. Disabled by default because Spark plan traversal adds overhead and metrics require a sink to be useful. This config must be se [...]
diff --git a/_sources/user-guide/latest/tuning.md.txt b/_sources/user-guide/latest/tuning.md.txt
index 205721408d..98056ec860 100644
--- a/_sources/user-guide/latest/tuning.md.txt
+++ b/_sources/user-guide/latest/tuning.md.txt
@@ -231,9 +231,20 @@ suggested) to overlap I/O across files at the cost of extra memory.
## Optimizing Sorting on Floating-Point Values
-Sorting on floating-point data types (or complex types containing floating-point values) is not compatible with
-Spark if the data contains both zero and negative zero. This is likely an edge case that is not of concern for many users
-and sorting on floating-point data can be enabled by setting `spark.comet.expression.SortOrder.allowIncompatible=true`.
+Comet normalizes NaN payloads and signed zeros in scalar `FLOAT` and `DOUBLE` ordering keys, so `ORDER BY`, window
+ordering and range partitioning on them match Spark and stay native even with
+`spark.comet.exec.strictFloatingPoint=true`. Only the comparison key is normalized; returned values keep their original
+NaN representation and zero sign.
+
+Floating-point values nested in arrays, structs, or maps are compared with Arrow's raw total ordering instead, which can
+differ from Spark when the data contains both zero and negative zero, or more than one NaN representation. This is likely
+an edge case that is not of concern for many users. Setting `spark.comet.exec.strictFloatingPoint=true` makes those
+nested cases fall back to Spark, and they can be forced back onto the native path with
+`spark.comet.expression.SortOrder.allowIncompatible=true`.
+
+`sort_array` is separate. It sorts array elements rather than ordering rows, and its elements are compared with Arrow's
+raw total ordering, so `spark.comet.exec.strictFloatingPoint=true` makes it fall back even for a scalar floating-point
+element type. Use `spark.comet.expression.SortArray.allowIncompatible=true` to keep it native.
## Optimizing Joins
diff --git a/searchindex.js b/searchindex.js
index 5ce74d0af2..9eaaa9ee8d 100644
--- a/searchindex.js
+++ b/searchindex.js
@@ -1 +1 @@
-Search.setIndex({"alltitles": {"!": [[56, "id1"]], "%": [[54, "id1"]], "&": [[44, "id1"]], "*": [[54, "id2"]], "+": [[54, "id3"]], "-": [[54, "id4"]], "/": [[54, "id5"]], "1. Format Your Code": [[41, "format-your-code"]], "1. Install Comet": [[62, "install-comet"], [73, "install-comet"]], "1. Native Operators (nativeExecs map)": [[28, "native-operators-nativeexecs-map"]], "2. Build and Verify": [[41, "build-and-verify"]], "2. Clone Iceberg and Apply Diff": [[62, "clone-iceberg-and-apply- [...]
\ No newline at end of file
+Search.setIndex({"alltitles": {"!": [[56, "id1"]], "%": [[54, "id1"]], "&": [[44, "id1"]], "*": [[54, "id2"]], "+": [[54, "id3"]], "-": [[54, "id4"]], "/": [[54, "id5"]], "1. Format Your Code": [[41, "format-your-code"]], "1. Install Comet": [[62, "install-comet"], [73, "install-comet"]], "1. Native Operators (nativeExecs map)": [[28, "native-operators-nativeexecs-map"]], "2. Build and Verify": [[41, "build-and-verify"]], "2. Clone Iceberg and Apply Diff": [[62, "clone-iceberg-and-apply- [...]
\ No newline at end of file
diff --git a/user-guide/latest/compatibility/expressions/spark-3.4/misc.html b/user-guide/latest/compatibility/expressions/spark-3.4/misc.html
index 92e1852607..addb3c87cd 100644
--- a/user-guide/latest/compatibility/expressions/spark-3.4/misc.html
+++ b/user-guide/latest/compatibility/expressions/spark-3.4/misc.html
@@ -815,7 +815,7 @@ under the License.
<h2>SortOrder<a class="headerlink" href="#sortorder" title="Link to this heading">#</a></h2>
<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">SortOrder</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.SortOrder.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
<ul class="simple">
-<li><p>When <code class="docutils literal notranslate"><span class="pre">spark.comet.exec.strictFloatingPoint=true</span></code>, sorting on floating-point types is not 100% compatible with Spark</p></li>
+<li><p>Sorting on floating-point values nested in arrays, structs, or maps is not 100% compatible with Spark when <code class="docutils literal notranslate"><span class="pre">spark.comet.exec.strictFloatingPoint=true</span></code></p></li>
</ul>
</section>
<section id="staticinvoke">
diff --git a/user-guide/latest/compatibility/expressions/spark-3.5/misc.html b/user-guide/latest/compatibility/expressions/spark-3.5/misc.html
index 899401979a..a1fc764785 100644
--- a/user-guide/latest/compatibility/expressions/spark-3.5/misc.html
+++ b/user-guide/latest/compatibility/expressions/spark-3.5/misc.html
@@ -815,7 +815,7 @@ under the License.
<h2>SortOrder<a class="headerlink" href="#sortorder" title="Link to this heading">#</a></h2>
<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">SortOrder</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.SortOrder.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
<ul class="simple">
-<li><p>When <code class="docutils literal notranslate"><span class="pre">spark.comet.exec.strictFloatingPoint=true</span></code>, sorting on floating-point types is not 100% compatible with Spark</p></li>
+<li><p>Sorting on floating-point values nested in arrays, structs, or maps is not 100% compatible with Spark when <code class="docutils literal notranslate"><span class="pre">spark.comet.exec.strictFloatingPoint=true</span></code></p></li>
</ul>
</section>
<section id="staticinvoke">
diff --git a/user-guide/latest/compatibility/expressions/spark-4.0/misc.html b/user-guide/latest/compatibility/expressions/spark-4.0/misc.html
index 516e5b0cfa..cf13ebdad8 100644
--- a/user-guide/latest/compatibility/expressions/spark-4.0/misc.html
+++ b/user-guide/latest/compatibility/expressions/spark-4.0/misc.html
@@ -815,7 +815,7 @@ under the License.
<h2>SortOrder<a class="headerlink" href="#sortorder" title="Link to this heading">#</a></h2>
<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">SortOrder</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.SortOrder.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
<ul class="simple">
-<li><p>When <code class="docutils literal notranslate"><span class="pre">spark.comet.exec.strictFloatingPoint=true</span></code>, sorting on floating-point types is not 100% compatible with Spark</p></li>
+<li><p>Sorting on floating-point values nested in arrays, structs, or maps is not 100% compatible with Spark when <code class="docutils literal notranslate"><span class="pre">spark.comet.exec.strictFloatingPoint=true</span></code></p></li>
</ul>
</section>
<section id="staticinvoke">
diff --git a/user-guide/latest/compatibility/expressions/spark-4.1/misc.html b/user-guide/latest/compatibility/expressions/spark-4.1/misc.html
index 31106fe258..f6358a23d2 100644
--- a/user-guide/latest/compatibility/expressions/spark-4.1/misc.html
+++ b/user-guide/latest/compatibility/expressions/spark-4.1/misc.html
@@ -815,7 +815,7 @@ under the License.
<h2>SortOrder<a class="headerlink" href="#sortorder" title="Link to this heading">#</a></h2>
<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">SortOrder</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.SortOrder.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
<ul class="simple">
-<li><p>When <code class="docutils literal notranslate"><span class="pre">spark.comet.exec.strictFloatingPoint=true</span></code>, sorting on floating-point types is not 100% compatible with Spark</p></li>
+<li><p>Sorting on floating-point values nested in arrays, structs, or maps is not 100% compatible with Spark when <code class="docutils literal notranslate"><span class="pre">spark.comet.exec.strictFloatingPoint=true</span></code></p></li>
</ul>
</section>
<section id="staticinvoke">
diff --git a/user-guide/latest/compatibility/floating-point.html b/user-guide/latest/compatibility/floating-point.html
index 85ecc31c20..1682e47d82 100644
--- a/user-guide/latest/compatibility/floating-point.html
+++ b/user-guide/latest/compatibility/floating-point.html
@@ -796,9 +796,11 @@ are normalized; returned values retain their original NaN representations and ze
<p>Native sorting of floating-point values nested in arrays or structs still uses Arrow’s raw total
ordering. Nested keys can therefore produce different ordering or rank results from Spark; see
<a class="reference external" href="https://github.com/apache/datafusion-comet/issues/5507">#5507</a>.</p>
-<p>The existing <code class="docutils literal notranslate"><span class="pre">spark.comet.exec.strictFloatingPoint=true</span></code> fallback policy is unchanged, including
-its conservative fallback for scalar floating-point sort keys. Narrowing that scalar-sort
-admission policy is tracked in <a class="reference external" href="https://github.com/apache/datafusion-comet/issues/5506">#5506</a>.</p>
+<p>Because those scalar comparison keys match Spark, <code class="docutils literal notranslate"><span class="pre">spark.comet.exec.strictFloatingPoint=true</span></code> no
+longer forces a fallback for them: scalar <code class="docutils literal notranslate"><span class="pre">FLOAT</span></code> and <code class="docutils literal notranslate"><span class="pre">DOUBLE</span></code> sort keys, window and rank order
+keys, and range partitioning keys all stay native under strict mode. Floating-point values nested
+in arrays, structs, or maps still fall back under strict mode, because their ordering is the raw
+total ordering described above.</p>
</section>
</section>
diff --git a/user-guide/latest/configs.html b/user-guide/latest/configs.html
index e22fc8eabb..5ad16a0e2e 100644
--- a/user-guide/latest/configs.html
+++ b/user-guide/latest/configs.html
@@ -906,7 +906,7 @@ under the License.
<td><p>true</p></td>
</tr>
<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">spark.comet.exec.strictFloatingPoint</span></code></p></td>
-<td><p>When enabled, fall back to Spark for floating-point operations that may differ from Spark, such as when comparing or sorting -0.0 and 0.0. For more information, refer to the <a class="reference external" href="https://datafusion.apache.org/comet/user-guide/latest/compatibility/index.html">Comet Compatibility Guide</a>.</p></td>
+<td><p>When enabled, fall back to Spark for floating-point operations that may differ from Spark, such as comparing -0.0 and 0.0, sorting floating-point values nested in arrays, structs, or maps, or sorting the elements of a floating-point array with <code class="docutils literal notranslate"><span class="pre">sort_array</span></code>. Scalar <code class="docutils literal notranslate"><span class="pre">ORDER</span> <span class="pre">BY</span></code>, window ordering and range partitionin [...]
<td><p>false</p></td>
</tr>
<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">spark.comet.exec.transitionRevert.enabled</span></code></p></td>
diff --git a/user-guide/latest/tuning.html b/user-guide/latest/tuning.html
index 7264bff312..fc3dc849fa 100644
--- a/user-guide/latest/tuning.html
+++ b/user-guide/latest/tuning.html
@@ -961,9 +961,18 @@ suggested) to overlap I/O across files at the cost of extra memory.</p>
</section>
<section id="optimizing-sorting-on-floating-point-values">
<h2>Optimizing Sorting on Floating-Point Values<a class="headerlink" href="#optimizing-sorting-on-floating-point-values" title="Link to this heading">#</a></h2>
-<p>Sorting on floating-point data types (or complex types containing floating-point values) is not compatible with
-Spark if the data contains both zero and negative zero. This is likely an edge case that is not of concern for many users
-and sorting on floating-point data can be enabled by setting <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.SortOrder.allowIncompatible=true</span></code>.</p>
+<p>Comet normalizes NaN payloads and signed zeros in scalar <code class="docutils literal notranslate"><span class="pre">FLOAT</span></code> and <code class="docutils literal notranslate"><span class="pre">DOUBLE</span></code> ordering keys, so <code class="docutils literal notranslate"><span class="pre">ORDER</span> <span class="pre">BY</span></code>, window
+ordering and range partitioning on them match Spark and stay native even with
+<code class="docutils literal notranslate"><span class="pre">spark.comet.exec.strictFloatingPoint=true</span></code>. Only the comparison key is normalized; returned values keep their original
+NaN representation and zero sign.</p>
+<p>Floating-point values nested in arrays, structs, or maps are compared with Arrow’s raw total ordering instead, which can
+differ from Spark when the data contains both zero and negative zero, or more than one NaN representation. This is likely
+an edge case that is not of concern for many users. Setting <code class="docutils literal notranslate"><span class="pre">spark.comet.exec.strictFloatingPoint=true</span></code> makes those
+nested cases fall back to Spark, and they can be forced back onto the native path with
+<code class="docutils literal notranslate"><span class="pre">spark.comet.expression.SortOrder.allowIncompatible=true</span></code>.</p>
+<p><code class="docutils literal notranslate"><span class="pre">sort_array</span></code> is separate. It sorts array elements rather than ordering rows, and its elements are compared with Arrow’s
+raw total ordering, so <code class="docutils literal notranslate"><span class="pre">spark.comet.exec.strictFloatingPoint=true</span></code> makes it fall back even for a scalar floating-point
+element type. Use <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.SortArray.allowIncompatible=true</span></code> to keep it native.</p>
</section>
<section id="optimizing-joins">
<h2>Optimizing Joins<a class="headerlink" href="#optimizing-joins" title="Link to this heading">#</a></h2>
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datafusion.apache.org
For additional commands, e-mail: commits-help@datafusion.apache.org