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/02 06:39:47 UTC
(datafusion-comet) branch asf-site updated: Publish built docs triggered by 33ea8c0dbebcc86abd099ab844c323d260908e4a
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 a809d37923 Publish built docs triggered by 33ea8c0dbebcc86abd099ab844c323d260908e4a
a809d37923 is described below
commit a809d37923dbafedfe1d267c4c80306202c9caa9
Author: github-actions[bot] <gi...@users.noreply.github.com>
AuthorDate: Fri Oct 2 06:39:41 2026 +0000
Publish built docs triggered by 33ea8c0dbebcc86abd099ab844c323d260908e4a
---
...id-f5b40459e5fe9b892b845c9198fe1c9420e05d14.svg | 2 +-
.../expressions/spark-3.4/aggregate.md.txt | 30 ++++++++++++++++
.../expressions/spark-3.5/aggregate.md.txt | 30 ++++++++++++++++
.../expressions/spark-4.0/aggregate.md.txt | 30 ++++++++++++++++
.../expressions/spark-4.1/aggregate.md.txt | 30 ++++++++++++++++
.../expressions/spark-4.2/aggregate.md.txt | 30 ++++++++++++++++
.../user-guide/latest/compatibility/scans.md.txt | 5 +++
_sources/user-guide/latest/expressions.md.txt | 12 +++----
searchindex.js | 2 +-
.../expressions/spark-3.4/aggregate.html | 40 ++++++++++++++++++++++
.../expressions/spark-3.5/aggregate.html | 40 ++++++++++++++++++++++
.../expressions/spark-4.0/aggregate.html | 40 ++++++++++++++++++++++
.../expressions/spark-4.1/aggregate.html | 40 ++++++++++++++++++++++
.../expressions/spark-4.2/aggregate.html | 40 ++++++++++++++++++++++
user-guide/latest/compatibility/scans.html | 5 +++
user-guide/latest/expressions.html | 12 +++----
16 files changed, 374 insertions(+), 14 deletions(-)
diff --git a/_images/mermaid-f5b40459e5fe9b892b845c9198fe1c9420e05d14.svg b/_images/mermaid-f5b40459e5fe9b892b845c9198fe1c9420e05d14.svg
index f5aa8a1d85..393aa56dc2 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/aggregate.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-3.4/aggregate.md.txt
index c5fd4a5248..6b39f6ad45 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-3.4/aggregate.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-3.4/aggregate.md.txt
@@ -96,4 +96,34 @@ The following cases are not supported by Comet and always fall back to Spark, re
- A frequency argument is not supported.
- Descending order in `WITHIN GROUP (ORDER BY ... DESC)` is not supported.
- Only numeric input types are supported.
+
+## RegrIntercept
+
+The following incompatibilities cause `RegrIntercept` to fall back to Spark by default. Set `spark.comet.expression.RegrIntercept.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_intercept` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
+
+## RegrR2
+
+The following incompatibilities cause `RegrR2` to fall back to Spark by default. Set `spark.comet.expression.RegrR2.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_r2` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
+
+## RegrReplacement
+
+The following incompatibilities cause `RegrReplacement` to fall back to Spark by default. Set `spark.comet.expression.RegrReplacement.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_sxx` and `regr_syy` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
+
+## RegrSXY
+
+The following incompatibilities cause `RegrSXY` to fall back to Spark by default. Set `spark.comet.expression.RegrSXY.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_sxy` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
+
+## RegrSlope
+
+The following incompatibilities cause `RegrSlope` to fall back to Spark by default. Set `spark.comet.expression.RegrSlope.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_slope` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
<!--END:EXPR_COMPAT-->
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-3.5/aggregate.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-3.5/aggregate.md.txt
index c5fd4a5248..6b39f6ad45 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-3.5/aggregate.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-3.5/aggregate.md.txt
@@ -96,4 +96,34 @@ The following cases are not supported by Comet and always fall back to Spark, re
- A frequency argument is not supported.
- Descending order in `WITHIN GROUP (ORDER BY ... DESC)` is not supported.
- Only numeric input types are supported.
+
+## RegrIntercept
+
+The following incompatibilities cause `RegrIntercept` to fall back to Spark by default. Set `spark.comet.expression.RegrIntercept.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_intercept` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
+
+## RegrR2
+
+The following incompatibilities cause `RegrR2` to fall back to Spark by default. Set `spark.comet.expression.RegrR2.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_r2` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
+
+## RegrReplacement
+
+The following incompatibilities cause `RegrReplacement` to fall back to Spark by default. Set `spark.comet.expression.RegrReplacement.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_sxx` and `regr_syy` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
+
+## RegrSXY
+
+The following incompatibilities cause `RegrSXY` to fall back to Spark by default. Set `spark.comet.expression.RegrSXY.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_sxy` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
+
+## RegrSlope
+
+The following incompatibilities cause `RegrSlope` to fall back to Spark by default. Set `spark.comet.expression.RegrSlope.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_slope` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
<!--END:EXPR_COMPAT-->
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-4.0/aggregate.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-4.0/aggregate.md.txt
index d6df4429a7..1780aadbb3 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-4.0/aggregate.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-4.0/aggregate.md.txt
@@ -129,4 +129,34 @@ The following cases are not supported by Comet and always fall back to Spark, re
- A frequency argument is not supported.
- Descending order in `WITHIN GROUP (ORDER BY ... DESC)` is not supported.
- Only numeric input types are supported.
+
+## RegrIntercept
+
+The following incompatibilities cause `RegrIntercept` to fall back to Spark by default. Set `spark.comet.expression.RegrIntercept.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_intercept` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
+
+## RegrR2
+
+The following incompatibilities cause `RegrR2` to fall back to Spark by default. Set `spark.comet.expression.RegrR2.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_r2` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
+
+## RegrReplacement
+
+The following incompatibilities cause `RegrReplacement` to fall back to Spark by default. Set `spark.comet.expression.RegrReplacement.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_sxx` and `regr_syy` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
+
+## RegrSXY
+
+The following incompatibilities cause `RegrSXY` to fall back to Spark by default. Set `spark.comet.expression.RegrSXY.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_sxy` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
+
+## RegrSlope
+
+The following incompatibilities cause `RegrSlope` to fall back to Spark by default. Set `spark.comet.expression.RegrSlope.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_slope` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
<!--END:EXPR_COMPAT-->
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-4.1/aggregate.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-4.1/aggregate.md.txt
index d6df4429a7..1780aadbb3 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-4.1/aggregate.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-4.1/aggregate.md.txt
@@ -129,4 +129,34 @@ The following cases are not supported by Comet and always fall back to Spark, re
- A frequency argument is not supported.
- Descending order in `WITHIN GROUP (ORDER BY ... DESC)` is not supported.
- Only numeric input types are supported.
+
+## RegrIntercept
+
+The following incompatibilities cause `RegrIntercept` to fall back to Spark by default. Set `spark.comet.expression.RegrIntercept.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_intercept` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
+
+## RegrR2
+
+The following incompatibilities cause `RegrR2` to fall back to Spark by default. Set `spark.comet.expression.RegrR2.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_r2` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
+
+## RegrReplacement
+
+The following incompatibilities cause `RegrReplacement` to fall back to Spark by default. Set `spark.comet.expression.RegrReplacement.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_sxx` and `regr_syy` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
+
+## RegrSXY
+
+The following incompatibilities cause `RegrSXY` to fall back to Spark by default. Set `spark.comet.expression.RegrSXY.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_sxy` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
+
+## RegrSlope
+
+The following incompatibilities cause `RegrSlope` to fall back to Spark by default. Set `spark.comet.expression.RegrSlope.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_slope` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
<!--END:EXPR_COMPAT-->
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-4.2/aggregate.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-4.2/aggregate.md.txt
index 08948e583d..84db4e0570 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-4.2/aggregate.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-4.2/aggregate.md.txt
@@ -133,4 +133,34 @@ The following cases are not supported by Comet and always fall back to Spark, re
- A frequency argument is not supported.
- Descending order in `WITHIN GROUP (ORDER BY ... DESC)` is not supported.
- Only numeric input types are supported.
+
+## RegrIntercept
+
+The following incompatibilities cause `RegrIntercept` to fall back to Spark by default. Set `spark.comet.expression.RegrIntercept.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_intercept` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
+
+## RegrR2
+
+The following incompatibilities cause `RegrR2` to fall back to Spark by default. Set `spark.comet.expression.RegrR2.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_r2` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
+
+## RegrReplacement
+
+The following incompatibilities cause `RegrReplacement` to fall back to Spark by default. Set `spark.comet.expression.RegrReplacement.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_sxx` and `regr_syy` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
+
+## RegrSXY
+
+The following incompatibilities cause `RegrSXY` to fall back to Spark by default. Set `spark.comet.expression.RegrSXY.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_sxy` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
+
+## RegrSlope
+
+The following incompatibilities cause `RegrSlope` to fall back to Spark by default. Set `spark.comet.expression.RegrSlope.allowIncompatible=true` to enable Comet acceleration despite these differences.
+
+- Comet merges the partial aggregates of `regr_slope` in a different floating-point operation order from Spark. When a group's rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)
<!--END:EXPR_COMPAT-->
diff --git a/_sources/user-guide/latest/compatibility/scans.md.txt b/_sources/user-guide/latest/compatibility/scans.md.txt
index cba1d37083..7b7d2c198e 100644
--- a/_sources/user-guide/latest/compatibility/scans.md.txt
+++ b/_sources/user-guide/latest/compatibility/scans.md.txt
@@ -126,6 +126,11 @@ and `INT32 → DOUBLE` widening that Spark 4.0+ accepts unconditionally; `Timest
is rejected by Spark 3.x but accepted by Spark 4.0+). Comet aims to follow the per-version Spark
behavior.
+- **Conversion errors precede pushed row filters**. Empty files and files whose row groups or
+ pages are all pruned read without decode-time conversion errors. When row-filter pushdown is
+ enabled, Comet checks rejected conversions before reading surviving data pages, so a row filter
+ cannot suppress the error by discarding every row. Legacy LIST shape mismatches that Spark cannot
+ clip are rejected when the file is opened, including for empty and fully pruned files.
- **List conversion error paths assume Spark's standard encoding**. Comet inserts `list`
before the element name when reporting a rejected array element conversion. Arrow's schema
omits the repeated group name, so paths for legacy LIST encodings or custom group names may
diff --git a/_sources/user-guide/latest/expressions.md.txt b/_sources/user-guide/latest/expressions.md.txt
index 56fb4f5c22..11519235b3 100644
--- a/_sources/user-guide/latest/expressions.md.txt
+++ b/_sources/user-guide/latest/expressions.md.txt
@@ -126,12 +126,12 @@ The tables below list every Spark built-in expression with its current status.
| `regr_avgx` | ✅ | — | Native: Spark rewrites to `Average` (tests in [#4551](https://github.com/apache/datafusion-comet/pull/4551)) |
| `regr_avgy` | ✅ | — | Native: Spark rewrites to `Average` (tests in [#4551](https://github.com/apache/datafusion-comet/pull/4551)) |
| `regr_count` | ✅ | — | Native: Spark rewrites to `Count` (tests in [#4551](https://github.com/apache/datafusion-comet/pull/4551)) |
-| `regr_intercept` | ✅ | Native | |
-| `regr_r2` | ✅ | Native | |
-| `regr_slope` | ✅ | Native | |
-| `regr_sxx` | ✅ | — | |
-| `regr_sxy` | ✅ | Native | |
-| `regr_syy` | ✅ | — | |
+| `regr_intercept` | ✅ | Native | Falls back by default because the native merge of partial aggregates differs from Spark ([#6423](https://github.com/apache/datafusion-comet/issues/6423)); the native path is opt-in via `spark.comet.expression.RegrIntercept.allowIncompatible=true` |
+| `regr_r2` | ✅ | Native | Falls back by default because the native merge of partial aggregates differs from Spark ([#6423](https://github.com/apache/datafusion-comet/issues/6423)); the native path is opt-in via `spark.comet.expression.RegrR2.allowIncompatible=true` |
+| `regr_slope` | ✅ | Native | Falls back by default because the native merge of partial aggregates differs from Spark ([#6423](https://github.com/apache/datafusion-comet/issues/6423)); the native path is opt-in via `spark.comet.expression.RegrSlope.allowIncompatible=true` |
+| `regr_sxx` | ✅ | — | Falls back by default because the native merge of partial aggregates differs from Spark ([#6423](https://github.com/apache/datafusion-comet/issues/6423)); the native path is opt-in via `spark.comet.expression.RegrReplacement.allowIncompatible=true` (Spark plans `regr_sxx` as `RegrReplacement`) |
+| `regr_sxy` | ✅ | Native | Falls back by default because the native merge of partial aggregates differs from Spark ([#6423](https://github.com/apache/datafusion-comet/issues/6423)); the native path is opt-in via `spark.comet.expression.RegrSXY.allowIncompatible=true` |
+| `regr_syy` | ✅ | — | Falls back by default because the native merge of partial aggregates differs from Spark ([#6423](https://github.com/apache/datafusion-comet/issues/6423)); the native path is opt-in via `spark.comet.expression.RegrReplacement.allowIncompatible=true` (Spark plans `regr_syy` as `RegrReplacement`) |
| `skewness` | 🔜 | — | Not yet implemented natively |
| `some` | ✅ | — | |
| `std` | ✅ | Native | |
diff --git a/searchindex.js b/searchindex.js
index 29b349144a..91c80c0f5c 100644
--- a/searchindex.js
+++ b/searchindex.js
@@ -1 +1 @@
-Search.setIndex({"alltitles": {"!": [[57, "id1"]], "%": [[55, "id1"]], "&": [[45, "id1"]], "*": [[55, "id2"]], "+": [[55, "id3"]], "-": [[55, "id4"]], "/": [[55, "id5"]], "1. Format Your Code": [[42, "format-your-code"]], "1. Install Comet": [[63, "install-comet"], [75, "install-comet"]], "1. Native Operators (nativeExecs map)": [[28, "native-operators-nativeexecs-map"]], "2. Build and Verify": [[42, "build-and-verify"]], "2. Clone Iceberg and Apply Diff": [[63, "clone-iceberg-and-apply- [...]
\ No newline at end of file
+Search.setIndex({"alltitles": {"!": [[57, "id1"]], "%": [[55, "id1"]], "&": [[45, "id1"]], "*": [[55, "id2"]], "+": [[55, "id3"]], "-": [[55, "id4"]], "/": [[55, "id5"]], "1. Format Your Code": [[42, "format-your-code"]], "1. Install Comet": [[63, "install-comet"], [75, "install-comet"]], "1. Native Operators (nativeExecs map)": [[28, "native-operators-nativeexecs-map"]], "2. Build and Verify": [[42, "build-and-verify"]], "2. Clone Iceberg and Apply Diff": [[63, "clone-iceberg-and-apply- [...]
\ No newline at end of file
diff --git a/user-guide/latest/compatibility/expressions/spark-3.4/aggregate.html b/user-guide/latest/compatibility/expressions/spark-3.4/aggregate.html
index 36b98655fa..080d59154c 100644
--- a/user-guide/latest/compatibility/expressions/spark-3.4/aggregate.html
+++ b/user-guide/latest/compatibility/expressions/spark-3.4/aggregate.html
@@ -892,6 +892,41 @@ under the License.
<li><p>Descending order in <code class="docutils literal notranslate"><span class="pre">WITHIN</span> <span class="pre">GROUP</span> <span class="pre">(ORDER</span> <span class="pre">BY</span> <span class="pre">...</span> <span class="pre">DESC)</span></code> is not supported.</p></li>
<li><p>Only numeric input types are supported.</p></li>
</ul>
+</section>
+<section id="regrintercept">
+<h2>RegrIntercept<a class="headerlink" href="#regrintercept" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrIntercept</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrIntercept.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_intercept</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)</p></li>
+</ul>
+</section>
+<section id="regrr2">
+<h2>RegrR2<a class="headerlink" href="#regrr2" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrR2</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrR2.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_r2</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)</p></li>
+</ul>
+</section>
+<section id="regrreplacement">
+<h2>RegrReplacement<a class="headerlink" href="#regrreplacement" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrReplacement</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrReplacement.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_sxx</span></code> and <code class="docutils literal notranslate"><span class="pre">regr_syy</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NU [...]
+</ul>
+</section>
+<section id="regrsxy">
+<h2>RegrSXY<a class="headerlink" href="#regrsxy" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrSXY</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrSXY.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_sxy</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)</p></li>
+</ul>
+</section>
+<section id="regrslope">
+<h2>RegrSlope<a class="headerlink" href="#regrslope" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrSlope</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrSlope.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_slope</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)</p></li>
+</ul>
<!--END:EXPR_COMPAT-->
</section>
</section>
@@ -953,6 +988,11 @@ under the License.
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#minby">MinBy</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#mode">Mode</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#percentile">Percentile</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrintercept">RegrIntercept</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrr2">RegrR2</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrreplacement">RegrReplacement</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrsxy">RegrSXY</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrslope">RegrSlope</a></li>
</ul>
</nav></div>
diff --git a/user-guide/latest/compatibility/expressions/spark-3.5/aggregate.html b/user-guide/latest/compatibility/expressions/spark-3.5/aggregate.html
index 80a8eff160..916fa57f9a 100644
--- a/user-guide/latest/compatibility/expressions/spark-3.5/aggregate.html
+++ b/user-guide/latest/compatibility/expressions/spark-3.5/aggregate.html
@@ -892,6 +892,41 @@ under the License.
<li><p>Descending order in <code class="docutils literal notranslate"><span class="pre">WITHIN</span> <span class="pre">GROUP</span> <span class="pre">(ORDER</span> <span class="pre">BY</span> <span class="pre">...</span> <span class="pre">DESC)</span></code> is not supported.</p></li>
<li><p>Only numeric input types are supported.</p></li>
</ul>
+</section>
+<section id="regrintercept">
+<h2>RegrIntercept<a class="headerlink" href="#regrintercept" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrIntercept</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrIntercept.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_intercept</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)</p></li>
+</ul>
+</section>
+<section id="regrr2">
+<h2>RegrR2<a class="headerlink" href="#regrr2" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrR2</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrR2.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_r2</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)</p></li>
+</ul>
+</section>
+<section id="regrreplacement">
+<h2>RegrReplacement<a class="headerlink" href="#regrreplacement" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrReplacement</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrReplacement.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_sxx</span></code> and <code class="docutils literal notranslate"><span class="pre">regr_syy</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NU [...]
+</ul>
+</section>
+<section id="regrsxy">
+<h2>RegrSXY<a class="headerlink" href="#regrsxy" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrSXY</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrSXY.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_sxy</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)</p></li>
+</ul>
+</section>
+<section id="regrslope">
+<h2>RegrSlope<a class="headerlink" href="#regrslope" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrSlope</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrSlope.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_slope</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)</p></li>
+</ul>
<!--END:EXPR_COMPAT-->
</section>
</section>
@@ -953,6 +988,11 @@ under the License.
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#minby">MinBy</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#mode">Mode</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#percentile">Percentile</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrintercept">RegrIntercept</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrr2">RegrR2</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrreplacement">RegrReplacement</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrsxy">RegrSXY</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrslope">RegrSlope</a></li>
</ul>
</nav></div>
diff --git a/user-guide/latest/compatibility/expressions/spark-4.0/aggregate.html b/user-guide/latest/compatibility/expressions/spark-4.0/aggregate.html
index 5695bb9c01..2ef791b983 100644
--- a/user-guide/latest/compatibility/expressions/spark-4.0/aggregate.html
+++ b/user-guide/latest/compatibility/expressions/spark-4.0/aggregate.html
@@ -928,6 +928,41 @@ under the License.
<li><p>Descending order in <code class="docutils literal notranslate"><span class="pre">WITHIN</span> <span class="pre">GROUP</span> <span class="pre">(ORDER</span> <span class="pre">BY</span> <span class="pre">...</span> <span class="pre">DESC)</span></code> is not supported.</p></li>
<li><p>Only numeric input types are supported.</p></li>
</ul>
+</section>
+<section id="regrintercept">
+<h2>RegrIntercept<a class="headerlink" href="#regrintercept" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrIntercept</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrIntercept.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_intercept</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)</p></li>
+</ul>
+</section>
+<section id="regrr2">
+<h2>RegrR2<a class="headerlink" href="#regrr2" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrR2</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrR2.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_r2</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)</p></li>
+</ul>
+</section>
+<section id="regrreplacement">
+<h2>RegrReplacement<a class="headerlink" href="#regrreplacement" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrReplacement</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrReplacement.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_sxx</span></code> and <code class="docutils literal notranslate"><span class="pre">regr_syy</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NU [...]
+</ul>
+</section>
+<section id="regrsxy">
+<h2>RegrSXY<a class="headerlink" href="#regrsxy" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrSXY</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrSXY.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_sxy</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)</p></li>
+</ul>
+</section>
+<section id="regrslope">
+<h2>RegrSlope<a class="headerlink" href="#regrslope" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrSlope</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrSlope.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_slope</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)</p></li>
+</ul>
<!--END:EXPR_COMPAT-->
</section>
</section>
@@ -992,6 +1027,11 @@ under the License.
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#minby">MinBy</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#mode">Mode</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#percentile">Percentile</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrintercept">RegrIntercept</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrr2">RegrR2</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrreplacement">RegrReplacement</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrsxy">RegrSXY</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrslope">RegrSlope</a></li>
</ul>
</nav></div>
diff --git a/user-guide/latest/compatibility/expressions/spark-4.1/aggregate.html b/user-guide/latest/compatibility/expressions/spark-4.1/aggregate.html
index f09de25c1e..abe282e719 100644
--- a/user-guide/latest/compatibility/expressions/spark-4.1/aggregate.html
+++ b/user-guide/latest/compatibility/expressions/spark-4.1/aggregate.html
@@ -928,6 +928,41 @@ under the License.
<li><p>Descending order in <code class="docutils literal notranslate"><span class="pre">WITHIN</span> <span class="pre">GROUP</span> <span class="pre">(ORDER</span> <span class="pre">BY</span> <span class="pre">...</span> <span class="pre">DESC)</span></code> is not supported.</p></li>
<li><p>Only numeric input types are supported.</p></li>
</ul>
+</section>
+<section id="regrintercept">
+<h2>RegrIntercept<a class="headerlink" href="#regrintercept" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrIntercept</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrIntercept.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_intercept</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)</p></li>
+</ul>
+</section>
+<section id="regrr2">
+<h2>RegrR2<a class="headerlink" href="#regrr2" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrR2</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrR2.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_r2</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)</p></li>
+</ul>
+</section>
+<section id="regrreplacement">
+<h2>RegrReplacement<a class="headerlink" href="#regrreplacement" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrReplacement</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrReplacement.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_sxx</span></code> and <code class="docutils literal notranslate"><span class="pre">regr_syy</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NU [...]
+</ul>
+</section>
+<section id="regrsxy">
+<h2>RegrSXY<a class="headerlink" href="#regrsxy" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrSXY</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrSXY.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_sxy</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)</p></li>
+</ul>
+</section>
+<section id="regrslope">
+<h2>RegrSlope<a class="headerlink" href="#regrslope" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrSlope</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrSlope.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_slope</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)</p></li>
+</ul>
<!--END:EXPR_COMPAT-->
</section>
</section>
@@ -992,6 +1027,11 @@ under the License.
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#minby">MinBy</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#mode">Mode</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#percentile">Percentile</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrintercept">RegrIntercept</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrr2">RegrR2</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrreplacement">RegrReplacement</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrsxy">RegrSXY</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrslope">RegrSlope</a></li>
</ul>
</nav></div>
diff --git a/user-guide/latest/compatibility/expressions/spark-4.2/aggregate.html b/user-guide/latest/compatibility/expressions/spark-4.2/aggregate.html
index f79351ded9..14c2951b18 100644
--- a/user-guide/latest/compatibility/expressions/spark-4.2/aggregate.html
+++ b/user-guide/latest/compatibility/expressions/spark-4.2/aggregate.html
@@ -932,6 +932,41 @@ under the License.
<li><p>Descending order in <code class="docutils literal notranslate"><span class="pre">WITHIN</span> <span class="pre">GROUP</span> <span class="pre">(ORDER</span> <span class="pre">BY</span> <span class="pre">...</span> <span class="pre">DESC)</span></code> is not supported.</p></li>
<li><p>Only numeric input types are supported.</p></li>
</ul>
+</section>
+<section id="regrintercept">
+<h2>RegrIntercept<a class="headerlink" href="#regrintercept" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrIntercept</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrIntercept.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_intercept</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)</p></li>
+</ul>
+</section>
+<section id="regrr2">
+<h2>RegrR2<a class="headerlink" href="#regrr2" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrR2</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrR2.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_r2</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)</p></li>
+</ul>
+</section>
+<section id="regrreplacement">
+<h2>RegrReplacement<a class="headerlink" href="#regrreplacement" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrReplacement</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrReplacement.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_sxx</span></code> and <code class="docutils literal notranslate"><span class="pre">regr_syy</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NU [...]
+</ul>
+</section>
+<section id="regrsxy">
+<h2>RegrSXY<a class="headerlink" href="#regrsxy" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrSXY</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrSXY.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_sxy</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)</p></li>
+</ul>
+</section>
+<section id="regrslope">
+<h2>RegrSlope<a class="headerlink" href="#regrslope" title="Link to this heading">#</a></h2>
+<p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">RegrSlope</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrSlope.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
+<ul class="simple">
+<li><p>Comet merges the partial aggregates of <code class="docutils literal notranslate"><span class="pre">regr_slope</span></code> in a different floating-point operation order from Spark. When a group’s rows come from more than one partial aggregate and a variable is constant at a value that binary floating point cannot represent exactly, such as 0.1, Comet returns a wrong value where Spark returns NULL, 0.0 or 1.0 (https://github.com/apache/datafusion-comet/issues/6423)</p></li>
+</ul>
<!--END:EXPR_COMPAT-->
</section>
</section>
@@ -996,6 +1031,11 @@ under the License.
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#minby">MinBy</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#mode">Mode</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#percentile">Percentile</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrintercept">RegrIntercept</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrr2">RegrR2</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrreplacement">RegrReplacement</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrsxy">RegrSXY</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link" href="#regrslope">RegrSlope</a></li>
</ul>
</nav></div>
diff --git a/user-guide/latest/compatibility/scans.html b/user-guide/latest/compatibility/scans.html
index 31607ef3ee..650ca11c4f 100644
--- a/user-guide/latest/compatibility/scans.html
+++ b/user-guide/latest/compatibility/scans.html
@@ -905,6 +905,11 @@ and <code class="docutils literal notranslate"><span class="pre">INT32</span> <s
is rejected by Spark 3.x but accepted by Spark 4.0+). Comet aims to follow the per-version Spark
behavior.</p>
<ul class="simple">
+<li><p><strong>Conversion errors precede pushed row filters</strong>. Empty files and files whose row groups or
+pages are all pruned read without decode-time conversion errors. When row-filter pushdown is
+enabled, Comet checks rejected conversions before reading surviving data pages, so a row filter
+cannot suppress the error by discarding every row. Legacy LIST shape mismatches that Spark cannot
+clip are rejected when the file is opened, including for empty and fully pruned files.</p></li>
<li><p><strong>List conversion error paths assume Spark’s standard encoding</strong>. Comet inserts <code class="docutils literal notranslate"><span class="pre">list</span></code>
before the element name when reporting a rejected array element conversion. Arrow’s schema
omits the repeated group name, so paths for legacy LIST encodings or custom group names may
diff --git a/user-guide/latest/expressions.html b/user-guide/latest/expressions.html
index 7dbd02650d..4d36366afb 100644
--- a/user-guide/latest/expressions.html
+++ b/user-guide/latest/expressions.html
@@ -1108,32 +1108,32 @@ expressions. The following function families are <strong>not currently planned</
<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">regr_intercept</span></code></p></td>
<td><p>✅</p></td>
<td><p>Native</p></td>
-<td><p></p></td>
+<td><p>Falls back by default because the native merge of partial aggregates differs from Spark (<a class="reference external" href="https://github.com/apache/datafusion-comet/issues/6423">#6423</a>); the native path is opt-in via <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrIntercept.allowIncompatible=true</span></code></p></td>
</tr>
<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">regr_r2</span></code></p></td>
<td><p>✅</p></td>
<td><p>Native</p></td>
-<td><p></p></td>
+<td><p>Falls back by default because the native merge of partial aggregates differs from Spark (<a class="reference external" href="https://github.com/apache/datafusion-comet/issues/6423">#6423</a>); the native path is opt-in via <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrR2.allowIncompatible=true</span></code></p></td>
</tr>
<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">regr_slope</span></code></p></td>
<td><p>✅</p></td>
<td><p>Native</p></td>
-<td><p></p></td>
+<td><p>Falls back by default because the native merge of partial aggregates differs from Spark (<a class="reference external" href="https://github.com/apache/datafusion-comet/issues/6423">#6423</a>); the native path is opt-in via <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrSlope.allowIncompatible=true</span></code></p></td>
</tr>
<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">regr_sxx</span></code></p></td>
<td><p>✅</p></td>
<td><p>—</p></td>
-<td><p></p></td>
+<td><p>Falls back by default because the native merge of partial aggregates differs from Spark (<a class="reference external" href="https://github.com/apache/datafusion-comet/issues/6423">#6423</a>); the native path is opt-in via <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrReplacement.allowIncompatible=true</span></code> (Spark plans <code class="docutils literal notranslate"><span class="pre">regr_sxx</span></code> as <code class="docutils lit [...]
</tr>
<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">regr_sxy</span></code></p></td>
<td><p>✅</p></td>
<td><p>Native</p></td>
-<td><p></p></td>
+<td><p>Falls back by default because the native merge of partial aggregates differs from Spark (<a class="reference external" href="https://github.com/apache/datafusion-comet/issues/6423">#6423</a>); the native path is opt-in via <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrSXY.allowIncompatible=true</span></code></p></td>
</tr>
<tr class="row-even"><td><p><code class="docutils literal notranslate"><span class="pre">regr_syy</span></code></p></td>
<td><p>✅</p></td>
<td><p>—</p></td>
-<td><p></p></td>
+<td><p>Falls back by default because the native merge of partial aggregates differs from Spark (<a class="reference external" href="https://github.com/apache/datafusion-comet/issues/6423">#6423</a>); the native path is opt-in via <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegrReplacement.allowIncompatible=true</span></code> (Spark plans <code class="docutils literal notranslate"><span class="pre">regr_syy</span></code> as <code class="docutils lit [...]
</tr>
<tr class="row-odd"><td><p><code class="docutils literal notranslate"><span class="pre">skewness</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