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/06/25 14:10:33 UTC

(datafusion-comet) branch asf-site updated: Publish built docs triggered by 46b58411d9f9befa994460157ea32f2b56891e6a

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 e6a68d2d8d Publish built docs triggered by 46b58411d9f9befa994460157ea32f2b56891e6a
e6a68d2d8d is described below

commit e6a68d2d8dd9ceafcd849f01ca23b491868208fa
Author: github-actions[bot] <gi...@users.noreply.github.com>
AuthorDate: Thu Jun 25 14:10:29 2026 +0000

    Publish built docs triggered by 46b58411d9f9befa994460157ea32f2b56891e6a
---
 .../expressions/spark-3.4/array.md.txt             |  8 +--
 .../expressions/spark-3.4/datetime.md.txt          | 22 ++++----
 .../compatibility/expressions/spark-3.4/map.md.txt |  2 +-
 .../expressions/spark-3.4/string.md.txt            | 52 ++++++++++++++++++-
 .../expressions/spark-3.4/struct.md.txt            | 12 +++++
 .../expressions/spark-3.5/array.md.txt             |  8 +--
 .../expressions/spark-3.5/datetime.md.txt          | 22 ++++----
 .../compatibility/expressions/spark-3.5/map.md.txt |  2 +-
 .../expressions/spark-3.5/string.md.txt            | 52 ++++++++++++++++++-
 .../expressions/spark-3.5/struct.md.txt            | 12 +++++
 .../expressions/spark-4.0/array.md.txt             |  8 +--
 .../expressions/spark-4.0/datetime.md.txt          | 22 ++++----
 .../compatibility/expressions/spark-4.0/map.md.txt |  2 +-
 .../expressions/spark-4.0/string.md.txt            | 52 ++++++++++++++++++-
 .../expressions/spark-4.0/struct.md.txt            | 12 +++++
 .../expressions/spark-4.1/array.md.txt             |  8 +--
 .../expressions/spark-4.1/datetime.md.txt          | 22 ++++----
 .../compatibility/expressions/spark-4.1/map.md.txt |  2 +-
 .../expressions/spark-4.1/string.md.txt            | 52 ++++++++++++++++++-
 .../expressions/spark-4.1/struct.md.txt            | 12 +++++
 .../user-guide/latest/compatibility/index.md.txt   | 13 +++++
 searchindex.js                                     |  2 +-
 .../compatibility/expressions/spark-3.4/array.html |  8 +--
 .../expressions/spark-3.4/datetime.html            | 22 ++++----
 .../compatibility/expressions/spark-3.4/map.html   |  2 +-
 .../expressions/spark-3.4/string.html              | 60 +++++++++++++++++++++-
 .../expressions/spark-3.4/struct.html              | 14 +++++
 .../compatibility/expressions/spark-3.5/array.html |  8 +--
 .../expressions/spark-3.5/datetime.html            | 22 ++++----
 .../compatibility/expressions/spark-3.5/map.html   |  2 +-
 .../expressions/spark-3.5/string.html              | 60 +++++++++++++++++++++-
 .../expressions/spark-3.5/struct.html              | 14 +++++
 .../compatibility/expressions/spark-4.0/array.html |  8 +--
 .../expressions/spark-4.0/datetime.html            | 22 ++++----
 .../compatibility/expressions/spark-4.0/map.html   |  2 +-
 .../expressions/spark-4.0/string.html              | 60 +++++++++++++++++++++-
 .../expressions/spark-4.0/struct.html              | 14 +++++
 .../compatibility/expressions/spark-4.1/array.html |  8 +--
 .../expressions/spark-4.1/datetime.html            | 22 ++++----
 .../compatibility/expressions/spark-4.1/map.html   |  2 +-
 .../expressions/spark-4.1/string.html              | 60 +++++++++++++++++++++-
 .../expressions/spark-4.1/struct.html              | 14 +++++
 user-guide/latest/compatibility/index.html         | 12 +++++
 43 files changed, 706 insertions(+), 129 deletions(-)

diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-3.4/array.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-3.4/array.md.txt
index 826397f55c..87c8c8f4e7 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-3.4/array.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-3.4/array.md.txt
@@ -23,13 +23,13 @@ under the License.
 
 ## ArrayExcept
 
-By default, Comet accelerates `ArrayExcept` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.ArrayExcept.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `ArrayExcept`. Set `spark.comet.expression.ArrayExcept.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Null handling and ordering may differ from Spark
 
 ## ArrayIntersect
 
-By default, Comet accelerates `ArrayIntersect` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.ArrayIntersect.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `ArrayIntersect`. Set `spark.comet.expression.ArrayIntersect.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Result array element order may differ from Spark when the right array is longer than the left (DataFusion probes the longer side).
 
@@ -39,7 +39,7 @@ The following cases are not supported by Comet:
 
 ## ArrayJoin
 
-By default, Comet accelerates `ArrayJoin` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.ArrayJoin.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `ArrayJoin`. Set `spark.comet.expression.ArrayJoin.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Null handling may differ from Spark
 
@@ -57,7 +57,7 @@ The following cases are not supported by Comet:
 
 ## SortArray
 
-By default, Comet accelerates `SortArray` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.SortArray.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `SortArray`. Set `spark.comet.expression.SortArray.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - When `spark.comet.exec.strictFloatingPoint=true`, sorting on floating-point types is not 100% compatible with Spark
 
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-3.4/datetime.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-3.4/datetime.md.txt
index 0cd0004d4c..09babb62c0 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-3.4/datetime.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-3.4/datetime.md.txt
@@ -46,7 +46,7 @@ If you need to process dates far in the future with accurate timezone handling,
 
 ## ConvertTimezone
 
-By default, Comet accelerates `ConvertTimezone` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.ConvertTimezone.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `ConvertTimezone`. Set `spark.comet.expression.ConvertTimezone.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Comet's native timezone parser only accepts IANA zone IDs (e.g. `America/Los_Angeles`) and fixed offsets in `+HH:MM` form. Spark also accepts forms such as `GMT+1`, `UTC+1`, or three-letter abbreviations like `PST`; queries using those forms will throw a native parse error at execution time. See https://github.com/apache/datafusion-comet/issues/2013.
 
@@ -56,6 +56,10 @@ The following differences from Spark are always present and do not require any a
 
 - Format strings in a curated allow-list run natively via DataFusion's `to_char` for UTC sessions. Other format strings (including non-literal formats), as well as non-UTC sessions, route through Spark's own `DateFormatClass.doGenCode` via the Arrow-direct codegen dispatcher when `spark.comet.exec.scalaUDF.codegen.enabled=true` (the default). When the codegen dispatcher is disabled the operator falls back to Spark in those cases.
 
+By default, Comet runs a Spark-compatible implementation of `DateFormatClass`. Set `spark.comet.expression.DateFormatClass.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Non-UTC timezones may produce different results than Spark
+
 ## Days
 
 The following cases are not supported by Comet:
@@ -64,19 +68,19 @@ The following cases are not supported by Comet:
 
 ## FromUTCTimestamp
 
-By default, Comet accelerates `FromUTCTimestamp` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.FromUTCTimestamp.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `FromUTCTimestamp`. Set `spark.comet.expression.FromUTCTimestamp.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Comet's native timezone parser only accepts IANA zone IDs (e.g. `America/Los_Angeles`) and fixed offsets in `+HH:MM` form. Spark also accepts forms such as `GMT+1`, `UTC+1`, or three-letter abbreviations like `PST`; queries using those forms will throw a native parse error at execution time. See https://github.com/apache/datafusion-comet/issues/2013.
 
 ## FromUnixTime
 
-By default, Comet accelerates `FromUnixTime` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.FromUnixTime.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `FromUnixTime`. Set `spark.comet.expression.FromUnixTime.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Only supports the default datetime format pattern `yyyy-MM-dd HH:mm:ss`. DataFusion's valid timestamp range differs from Spark (https://github.com/apache/datafusion/issues/16594)
 
 ## Hour
 
-By default, Comet accelerates `Hour` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.Hour.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `Hour`. Set `spark.comet.expression.Hour.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Incorrectly applies timezone conversion to TimestampNTZ inputs (https://github.com/apache/datafusion-comet/issues/3180)
 
@@ -88,13 +92,13 @@ The following cases are not supported by Comet:
 
 ## Minute
 
-By default, Comet accelerates `Minute` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.Minute.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `Minute`. Set `spark.comet.expression.Minute.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Incorrectly applies timezone conversion to TimestampNTZ inputs (https://github.com/apache/datafusion-comet/issues/3180)
 
 ## Second
 
-By default, Comet accelerates `Second` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.Second.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `Second`. Set `spark.comet.expression.Second.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Incorrectly applies timezone conversion to TimestampNTZ inputs (https://github.com/apache/datafusion-comet/issues/3180)
 
@@ -106,13 +110,13 @@ The following cases are not supported by Comet:
 
 ## ToUTCTimestamp
 
-By default, Comet accelerates `ToUTCTimestamp` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.ToUTCTimestamp.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `ToUTCTimestamp`. Set `spark.comet.expression.ToUTCTimestamp.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Comet's native timezone parser only accepts IANA zone IDs (e.g. `America/Los_Angeles`) and fixed offsets in `+HH:MM` form. Spark also accepts forms such as `GMT+1`, `UTC+1`, or three-letter abbreviations like `PST`; queries using those forms will throw a native parse error at execution time. See https://github.com/apache/datafusion-comet/issues/2013.
 
 ## TruncDate
 
-By default, Comet accelerates `TruncDate` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.TruncDate.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `TruncDate`. Set `spark.comet.expression.TruncDate.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Non-literal format strings will throw an exception instead of returning NULL
 
@@ -122,7 +126,7 @@ The following cases are not supported by Comet:
 
 ## TruncTimestamp
 
-By default, Comet accelerates `TruncTimestamp` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.TruncTimestamp.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `TruncTimestamp`. Set `spark.comet.expression.TruncTimestamp.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Produces incorrect results when used with non-UTC timezones. Compatible when timezone is UTC. (https://github.com/apache/datafusion-comet/issues/2649)
 - Non-literal format strings will throw an exception instead of returning NULL
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-3.4/map.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-3.4/map.md.txt
index 24e4830b00..f748d346f1 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-3.4/map.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-3.4/map.md.txt
@@ -34,7 +34,7 @@ IEEE total ordering for floating-point, which differs from Spark's `Double.compa
 
 ## MapFromEntries
 
-By default, Comet accelerates `MapFromEntries` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.MapFromEntries.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `MapFromEntries`. Set `spark.comet.expression.MapFromEntries.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - `BinaryType` is not supported as a map key in `map_from_entries`
 - `BinaryType` is not supported as a map value in `map_from_entries`
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-3.4/string.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-3.4/string.md.txt
index a75b2cbca9..f20f499070 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-3.4/string.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-3.4/string.md.txt
@@ -29,7 +29,7 @@ The following cases are not supported by Comet:
 
 ## Concat
 
-By default, Comet accelerates `Concat` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.Concat.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `Concat`. Set `spark.comet.expression.Concat.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - concat does not support non-UTF8_BINARY collations (https://github.com/apache/datafusion-comet/issues/2190)
 
@@ -37,6 +37,18 @@ The following cases are not supported by Comet:
 
 - CONCAT supports only string input parameters
 
+## GetJsonObject
+
+By default, Comet runs a Spark-compatible implementation of `GetJsonObject`. Set `spark.comet.expression.GetJsonObject.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Spark allows single-quoted JSON and unescaped control characters which Comet does not support
+
+## InitCap
+
+By default, Comet runs a Spark-compatible implementation of `InitCap`. Set `spark.comet.expression.InitCap.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Treats hyphen as a word separator (e.g. `robert rose-smith` produces `Robert Rose-Smith` instead of Spark's `Robert Rose-smith`) (https://github.com/apache/datafusion-comet/issues/1052)
+
 ## Left
 
 The following cases are not supported by Comet:
@@ -50,15 +62,33 @@ The following cases are not supported by Comet:
 
 - `BinaryType` input is not supported
 
+## Lower
+
+By default, Comet runs a Spark-compatible implementation of `Lower`. Set `spark.comet.caseConversion.enabled=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Results can vary depending on locale and character set
+
 ## OctetLength
 
 The following cases are not supported by Comet:
 
 - `BinaryType` input is not supported
 
+## RLike
+
+By default, Comet runs a Spark-compatible implementation of `RLike`. Set `spark.comet.expression.RLike.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Uses Rust regexp engine, which has different behavior to Java regexp engine
+
+## RegExpReplace
+
+By default, Comet runs a Spark-compatible implementation of `RegExpReplace`. Set `spark.comet.expression.RegExpReplace.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Regexp pattern may not be compatible with Spark
+
 ## Reverse
 
-By default, Comet accelerates `Reverse` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.Reverse.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `Reverse`. Set `spark.comet.expression.Reverse.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - reverse on array containing binary is not supported
 - reverse does not support non-UTF8_BINARY collations (https://github.com/apache/datafusion-comet/issues/2190)
@@ -89,9 +119,27 @@ The following differences from Spark are always present and do not require any a
 
 - A negative argument for the number of times to repeat throws an exception instead of returning an empty string as Spark does
 
+## StringReplace
+
+By default, Comet runs a Spark-compatible implementation of `StringReplace`. Set `spark.comet.expression.StringReplace.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Produces different results from Spark when the search string is empty
+
+## StringSplit
+
+By default, Comet runs a Spark-compatible implementation of `StringSplit`. Set `spark.comet.expression.StringSplit.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Regex engine differences between Java and Rust
+
 ## StringTranslate
 
 The following incompatibilities cause `StringTranslate` to fall back to Spark by default. Set `spark.comet.expression.StringTranslate.allowIncompatible=true` to enable Comet acceleration despite these differences.
 
 - DataFusion's translate iterates over Unicode graphemes (Spark uses code points) and substitutes U+0000 instead of treating it as a deletion sentinel
+
+## Upper
+
+By default, Comet runs a Spark-compatible implementation of `Upper`. Set `spark.comet.caseConversion.enabled=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Results can vary depending on locale and character set
 <!--END:EXPR_COMPAT-->
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-3.4/struct.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-3.4/struct.md.txt
index 72db34d875..8c40efde43 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-3.4/struct.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-3.4/struct.md.txt
@@ -27,6 +27,12 @@ The following cases are not supported by Comet:
 
 - `CreateNamedStruct` with duplicate field names is not supported
 
+## JsonToStructs
+
+By default, Comet runs a Spark-compatible implementation of `JsonToStructs`. Set `spark.comet.expression.JsonToStructs.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Partially implemented and not comprehensively tested
+
 ## StructsToCsv
 
 The following incompatibilities cause `StructsToCsv` to fall back to Spark by default. Set `spark.comet.expression.StructsToCsv.allowIncompatible=true` to enable Comet acceleration despite these differences.
@@ -36,4 +42,10 @@ The following incompatibilities cause `StructsToCsv` to fall back to Spark by de
 The following cases are not supported by Comet:
 
 - Complex types (arrays, maps, structs) in the schema are not supported
+
+## StructsToJson
+
+By default, Comet runs a Spark-compatible implementation of `StructsToJson`. Set `spark.comet.expression.StructsToJson.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Does not support `+Infinity` and `-Infinity` for numeric types (float, double). (https://github.com/apache/datafusion-comet/issues/3016)
 <!--END:EXPR_COMPAT-->
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-3.5/array.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-3.5/array.md.txt
index 826397f55c..87c8c8f4e7 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-3.5/array.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-3.5/array.md.txt
@@ -23,13 +23,13 @@ under the License.
 
 ## ArrayExcept
 
-By default, Comet accelerates `ArrayExcept` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.ArrayExcept.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `ArrayExcept`. Set `spark.comet.expression.ArrayExcept.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Null handling and ordering may differ from Spark
 
 ## ArrayIntersect
 
-By default, Comet accelerates `ArrayIntersect` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.ArrayIntersect.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `ArrayIntersect`. Set `spark.comet.expression.ArrayIntersect.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Result array element order may differ from Spark when the right array is longer than the left (DataFusion probes the longer side).
 
@@ -39,7 +39,7 @@ The following cases are not supported by Comet:
 
 ## ArrayJoin
 
-By default, Comet accelerates `ArrayJoin` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.ArrayJoin.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `ArrayJoin`. Set `spark.comet.expression.ArrayJoin.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Null handling may differ from Spark
 
@@ -57,7 +57,7 @@ The following cases are not supported by Comet:
 
 ## SortArray
 
-By default, Comet accelerates `SortArray` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.SortArray.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `SortArray`. Set `spark.comet.expression.SortArray.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - When `spark.comet.exec.strictFloatingPoint=true`, sorting on floating-point types is not 100% compatible with Spark
 
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-3.5/datetime.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-3.5/datetime.md.txt
index 0cd0004d4c..09babb62c0 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-3.5/datetime.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-3.5/datetime.md.txt
@@ -46,7 +46,7 @@ If you need to process dates far in the future with accurate timezone handling,
 
 ## ConvertTimezone
 
-By default, Comet accelerates `ConvertTimezone` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.ConvertTimezone.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `ConvertTimezone`. Set `spark.comet.expression.ConvertTimezone.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Comet's native timezone parser only accepts IANA zone IDs (e.g. `America/Los_Angeles`) and fixed offsets in `+HH:MM` form. Spark also accepts forms such as `GMT+1`, `UTC+1`, or three-letter abbreviations like `PST`; queries using those forms will throw a native parse error at execution time. See https://github.com/apache/datafusion-comet/issues/2013.
 
@@ -56,6 +56,10 @@ The following differences from Spark are always present and do not require any a
 
 - Format strings in a curated allow-list run natively via DataFusion's `to_char` for UTC sessions. Other format strings (including non-literal formats), as well as non-UTC sessions, route through Spark's own `DateFormatClass.doGenCode` via the Arrow-direct codegen dispatcher when `spark.comet.exec.scalaUDF.codegen.enabled=true` (the default). When the codegen dispatcher is disabled the operator falls back to Spark in those cases.
 
+By default, Comet runs a Spark-compatible implementation of `DateFormatClass`. Set `spark.comet.expression.DateFormatClass.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Non-UTC timezones may produce different results than Spark
+
 ## Days
 
 The following cases are not supported by Comet:
@@ -64,19 +68,19 @@ The following cases are not supported by Comet:
 
 ## FromUTCTimestamp
 
-By default, Comet accelerates `FromUTCTimestamp` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.FromUTCTimestamp.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `FromUTCTimestamp`. Set `spark.comet.expression.FromUTCTimestamp.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Comet's native timezone parser only accepts IANA zone IDs (e.g. `America/Los_Angeles`) and fixed offsets in `+HH:MM` form. Spark also accepts forms such as `GMT+1`, `UTC+1`, or three-letter abbreviations like `PST`; queries using those forms will throw a native parse error at execution time. See https://github.com/apache/datafusion-comet/issues/2013.
 
 ## FromUnixTime
 
-By default, Comet accelerates `FromUnixTime` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.FromUnixTime.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `FromUnixTime`. Set `spark.comet.expression.FromUnixTime.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Only supports the default datetime format pattern `yyyy-MM-dd HH:mm:ss`. DataFusion's valid timestamp range differs from Spark (https://github.com/apache/datafusion/issues/16594)
 
 ## Hour
 
-By default, Comet accelerates `Hour` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.Hour.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `Hour`. Set `spark.comet.expression.Hour.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Incorrectly applies timezone conversion to TimestampNTZ inputs (https://github.com/apache/datafusion-comet/issues/3180)
 
@@ -88,13 +92,13 @@ The following cases are not supported by Comet:
 
 ## Minute
 
-By default, Comet accelerates `Minute` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.Minute.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `Minute`. Set `spark.comet.expression.Minute.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Incorrectly applies timezone conversion to TimestampNTZ inputs (https://github.com/apache/datafusion-comet/issues/3180)
 
 ## Second
 
-By default, Comet accelerates `Second` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.Second.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `Second`. Set `spark.comet.expression.Second.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Incorrectly applies timezone conversion to TimestampNTZ inputs (https://github.com/apache/datafusion-comet/issues/3180)
 
@@ -106,13 +110,13 @@ The following cases are not supported by Comet:
 
 ## ToUTCTimestamp
 
-By default, Comet accelerates `ToUTCTimestamp` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.ToUTCTimestamp.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `ToUTCTimestamp`. Set `spark.comet.expression.ToUTCTimestamp.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Comet's native timezone parser only accepts IANA zone IDs (e.g. `America/Los_Angeles`) and fixed offsets in `+HH:MM` form. Spark also accepts forms such as `GMT+1`, `UTC+1`, or three-letter abbreviations like `PST`; queries using those forms will throw a native parse error at execution time. See https://github.com/apache/datafusion-comet/issues/2013.
 
 ## TruncDate
 
-By default, Comet accelerates `TruncDate` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.TruncDate.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `TruncDate`. Set `spark.comet.expression.TruncDate.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Non-literal format strings will throw an exception instead of returning NULL
 
@@ -122,7 +126,7 @@ The following cases are not supported by Comet:
 
 ## TruncTimestamp
 
-By default, Comet accelerates `TruncTimestamp` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.TruncTimestamp.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `TruncTimestamp`. Set `spark.comet.expression.TruncTimestamp.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Produces incorrect results when used with non-UTC timezones. Compatible when timezone is UTC. (https://github.com/apache/datafusion-comet/issues/2649)
 - Non-literal format strings will throw an exception instead of returning NULL
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-3.5/map.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-3.5/map.md.txt
index 24e4830b00..f748d346f1 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-3.5/map.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-3.5/map.md.txt
@@ -34,7 +34,7 @@ IEEE total ordering for floating-point, which differs from Spark's `Double.compa
 
 ## MapFromEntries
 
-By default, Comet accelerates `MapFromEntries` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.MapFromEntries.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `MapFromEntries`. Set `spark.comet.expression.MapFromEntries.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - `BinaryType` is not supported as a map key in `map_from_entries`
 - `BinaryType` is not supported as a map value in `map_from_entries`
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-3.5/string.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-3.5/string.md.txt
index a75b2cbca9..f20f499070 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-3.5/string.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-3.5/string.md.txt
@@ -29,7 +29,7 @@ The following cases are not supported by Comet:
 
 ## Concat
 
-By default, Comet accelerates `Concat` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.Concat.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `Concat`. Set `spark.comet.expression.Concat.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - concat does not support non-UTF8_BINARY collations (https://github.com/apache/datafusion-comet/issues/2190)
 
@@ -37,6 +37,18 @@ The following cases are not supported by Comet:
 
 - CONCAT supports only string input parameters
 
+## GetJsonObject
+
+By default, Comet runs a Spark-compatible implementation of `GetJsonObject`. Set `spark.comet.expression.GetJsonObject.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Spark allows single-quoted JSON and unescaped control characters which Comet does not support
+
+## InitCap
+
+By default, Comet runs a Spark-compatible implementation of `InitCap`. Set `spark.comet.expression.InitCap.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Treats hyphen as a word separator (e.g. `robert rose-smith` produces `Robert Rose-Smith` instead of Spark's `Robert Rose-smith`) (https://github.com/apache/datafusion-comet/issues/1052)
+
 ## Left
 
 The following cases are not supported by Comet:
@@ -50,15 +62,33 @@ The following cases are not supported by Comet:
 
 - `BinaryType` input is not supported
 
+## Lower
+
+By default, Comet runs a Spark-compatible implementation of `Lower`. Set `spark.comet.caseConversion.enabled=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Results can vary depending on locale and character set
+
 ## OctetLength
 
 The following cases are not supported by Comet:
 
 - `BinaryType` input is not supported
 
+## RLike
+
+By default, Comet runs a Spark-compatible implementation of `RLike`. Set `spark.comet.expression.RLike.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Uses Rust regexp engine, which has different behavior to Java regexp engine
+
+## RegExpReplace
+
+By default, Comet runs a Spark-compatible implementation of `RegExpReplace`. Set `spark.comet.expression.RegExpReplace.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Regexp pattern may not be compatible with Spark
+
 ## Reverse
 
-By default, Comet accelerates `Reverse` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.Reverse.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `Reverse`. Set `spark.comet.expression.Reverse.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - reverse on array containing binary is not supported
 - reverse does not support non-UTF8_BINARY collations (https://github.com/apache/datafusion-comet/issues/2190)
@@ -89,9 +119,27 @@ The following differences from Spark are always present and do not require any a
 
 - A negative argument for the number of times to repeat throws an exception instead of returning an empty string as Spark does
 
+## StringReplace
+
+By default, Comet runs a Spark-compatible implementation of `StringReplace`. Set `spark.comet.expression.StringReplace.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Produces different results from Spark when the search string is empty
+
+## StringSplit
+
+By default, Comet runs a Spark-compatible implementation of `StringSplit`. Set `spark.comet.expression.StringSplit.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Regex engine differences between Java and Rust
+
 ## StringTranslate
 
 The following incompatibilities cause `StringTranslate` to fall back to Spark by default. Set `spark.comet.expression.StringTranslate.allowIncompatible=true` to enable Comet acceleration despite these differences.
 
 - DataFusion's translate iterates over Unicode graphemes (Spark uses code points) and substitutes U+0000 instead of treating it as a deletion sentinel
+
+## Upper
+
+By default, Comet runs a Spark-compatible implementation of `Upper`. Set `spark.comet.caseConversion.enabled=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Results can vary depending on locale and character set
 <!--END:EXPR_COMPAT-->
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-3.5/struct.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-3.5/struct.md.txt
index 72db34d875..8c40efde43 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-3.5/struct.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-3.5/struct.md.txt
@@ -27,6 +27,12 @@ The following cases are not supported by Comet:
 
 - `CreateNamedStruct` with duplicate field names is not supported
 
+## JsonToStructs
+
+By default, Comet runs a Spark-compatible implementation of `JsonToStructs`. Set `spark.comet.expression.JsonToStructs.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Partially implemented and not comprehensively tested
+
 ## StructsToCsv
 
 The following incompatibilities cause `StructsToCsv` to fall back to Spark by default. Set `spark.comet.expression.StructsToCsv.allowIncompatible=true` to enable Comet acceleration despite these differences.
@@ -36,4 +42,10 @@ The following incompatibilities cause `StructsToCsv` to fall back to Spark by de
 The following cases are not supported by Comet:
 
 - Complex types (arrays, maps, structs) in the schema are not supported
+
+## StructsToJson
+
+By default, Comet runs a Spark-compatible implementation of `StructsToJson`. Set `spark.comet.expression.StructsToJson.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Does not support `+Infinity` and `-Infinity` for numeric types (float, double). (https://github.com/apache/datafusion-comet/issues/3016)
 <!--END:EXPR_COMPAT-->
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-4.0/array.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-4.0/array.md.txt
index 826397f55c..87c8c8f4e7 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-4.0/array.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-4.0/array.md.txt
@@ -23,13 +23,13 @@ under the License.
 
 ## ArrayExcept
 
-By default, Comet accelerates `ArrayExcept` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.ArrayExcept.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `ArrayExcept`. Set `spark.comet.expression.ArrayExcept.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Null handling and ordering may differ from Spark
 
 ## ArrayIntersect
 
-By default, Comet accelerates `ArrayIntersect` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.ArrayIntersect.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `ArrayIntersect`. Set `spark.comet.expression.ArrayIntersect.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Result array element order may differ from Spark when the right array is longer than the left (DataFusion probes the longer side).
 
@@ -39,7 +39,7 @@ The following cases are not supported by Comet:
 
 ## ArrayJoin
 
-By default, Comet accelerates `ArrayJoin` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.ArrayJoin.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `ArrayJoin`. Set `spark.comet.expression.ArrayJoin.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Null handling may differ from Spark
 
@@ -57,7 +57,7 @@ The following cases are not supported by Comet:
 
 ## SortArray
 
-By default, Comet accelerates `SortArray` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.SortArray.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `SortArray`. Set `spark.comet.expression.SortArray.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - When `spark.comet.exec.strictFloatingPoint=true`, sorting on floating-point types is not 100% compatible with Spark
 
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-4.0/datetime.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-4.0/datetime.md.txt
index 0cd0004d4c..09babb62c0 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-4.0/datetime.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-4.0/datetime.md.txt
@@ -46,7 +46,7 @@ If you need to process dates far in the future with accurate timezone handling,
 
 ## ConvertTimezone
 
-By default, Comet accelerates `ConvertTimezone` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.ConvertTimezone.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `ConvertTimezone`. Set `spark.comet.expression.ConvertTimezone.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Comet's native timezone parser only accepts IANA zone IDs (e.g. `America/Los_Angeles`) and fixed offsets in `+HH:MM` form. Spark also accepts forms such as `GMT+1`, `UTC+1`, or three-letter abbreviations like `PST`; queries using those forms will throw a native parse error at execution time. See https://github.com/apache/datafusion-comet/issues/2013.
 
@@ -56,6 +56,10 @@ The following differences from Spark are always present and do not require any a
 
 - Format strings in a curated allow-list run natively via DataFusion's `to_char` for UTC sessions. Other format strings (including non-literal formats), as well as non-UTC sessions, route through Spark's own `DateFormatClass.doGenCode` via the Arrow-direct codegen dispatcher when `spark.comet.exec.scalaUDF.codegen.enabled=true` (the default). When the codegen dispatcher is disabled the operator falls back to Spark in those cases.
 
+By default, Comet runs a Spark-compatible implementation of `DateFormatClass`. Set `spark.comet.expression.DateFormatClass.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Non-UTC timezones may produce different results than Spark
+
 ## Days
 
 The following cases are not supported by Comet:
@@ -64,19 +68,19 @@ The following cases are not supported by Comet:
 
 ## FromUTCTimestamp
 
-By default, Comet accelerates `FromUTCTimestamp` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.FromUTCTimestamp.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `FromUTCTimestamp`. Set `spark.comet.expression.FromUTCTimestamp.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Comet's native timezone parser only accepts IANA zone IDs (e.g. `America/Los_Angeles`) and fixed offsets in `+HH:MM` form. Spark also accepts forms such as `GMT+1`, `UTC+1`, or three-letter abbreviations like `PST`; queries using those forms will throw a native parse error at execution time. See https://github.com/apache/datafusion-comet/issues/2013.
 
 ## FromUnixTime
 
-By default, Comet accelerates `FromUnixTime` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.FromUnixTime.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `FromUnixTime`. Set `spark.comet.expression.FromUnixTime.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Only supports the default datetime format pattern `yyyy-MM-dd HH:mm:ss`. DataFusion's valid timestamp range differs from Spark (https://github.com/apache/datafusion/issues/16594)
 
 ## Hour
 
-By default, Comet accelerates `Hour` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.Hour.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `Hour`. Set `spark.comet.expression.Hour.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Incorrectly applies timezone conversion to TimestampNTZ inputs (https://github.com/apache/datafusion-comet/issues/3180)
 
@@ -88,13 +92,13 @@ The following cases are not supported by Comet:
 
 ## Minute
 
-By default, Comet accelerates `Minute` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.Minute.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `Minute`. Set `spark.comet.expression.Minute.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Incorrectly applies timezone conversion to TimestampNTZ inputs (https://github.com/apache/datafusion-comet/issues/3180)
 
 ## Second
 
-By default, Comet accelerates `Second` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.Second.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `Second`. Set `spark.comet.expression.Second.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Incorrectly applies timezone conversion to TimestampNTZ inputs (https://github.com/apache/datafusion-comet/issues/3180)
 
@@ -106,13 +110,13 @@ The following cases are not supported by Comet:
 
 ## ToUTCTimestamp
 
-By default, Comet accelerates `ToUTCTimestamp` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.ToUTCTimestamp.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `ToUTCTimestamp`. Set `spark.comet.expression.ToUTCTimestamp.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Comet's native timezone parser only accepts IANA zone IDs (e.g. `America/Los_Angeles`) and fixed offsets in `+HH:MM` form. Spark also accepts forms such as `GMT+1`, `UTC+1`, or three-letter abbreviations like `PST`; queries using those forms will throw a native parse error at execution time. See https://github.com/apache/datafusion-comet/issues/2013.
 
 ## TruncDate
 
-By default, Comet accelerates `TruncDate` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.TruncDate.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `TruncDate`. Set `spark.comet.expression.TruncDate.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Non-literal format strings will throw an exception instead of returning NULL
 
@@ -122,7 +126,7 @@ The following cases are not supported by Comet:
 
 ## TruncTimestamp
 
-By default, Comet accelerates `TruncTimestamp` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.TruncTimestamp.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `TruncTimestamp`. Set `spark.comet.expression.TruncTimestamp.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Produces incorrect results when used with non-UTC timezones. Compatible when timezone is UTC. (https://github.com/apache/datafusion-comet/issues/2649)
 - Non-literal format strings will throw an exception instead of returning NULL
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-4.0/map.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-4.0/map.md.txt
index 88840c0bc6..0595249b1a 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-4.0/map.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-4.0/map.md.txt
@@ -34,7 +34,7 @@ IEEE total ordering for floating-point, which differs from Spark's `Double.compa
 
 ## MapFromEntries
 
-By default, Comet accelerates `MapFromEntries` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.MapFromEntries.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `MapFromEntries`. Set `spark.comet.expression.MapFromEntries.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - `BinaryType` is not supported as a map key in `map_from_entries`
 - `BinaryType` is not supported as a map value in `map_from_entries`
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-4.0/string.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-4.0/string.md.txt
index a75b2cbca9..f20f499070 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-4.0/string.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-4.0/string.md.txt
@@ -29,7 +29,7 @@ The following cases are not supported by Comet:
 
 ## Concat
 
-By default, Comet accelerates `Concat` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.Concat.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `Concat`. Set `spark.comet.expression.Concat.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - concat does not support non-UTF8_BINARY collations (https://github.com/apache/datafusion-comet/issues/2190)
 
@@ -37,6 +37,18 @@ The following cases are not supported by Comet:
 
 - CONCAT supports only string input parameters
 
+## GetJsonObject
+
+By default, Comet runs a Spark-compatible implementation of `GetJsonObject`. Set `spark.comet.expression.GetJsonObject.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Spark allows single-quoted JSON and unescaped control characters which Comet does not support
+
+## InitCap
+
+By default, Comet runs a Spark-compatible implementation of `InitCap`. Set `spark.comet.expression.InitCap.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Treats hyphen as a word separator (e.g. `robert rose-smith` produces `Robert Rose-Smith` instead of Spark's `Robert Rose-smith`) (https://github.com/apache/datafusion-comet/issues/1052)
+
 ## Left
 
 The following cases are not supported by Comet:
@@ -50,15 +62,33 @@ The following cases are not supported by Comet:
 
 - `BinaryType` input is not supported
 
+## Lower
+
+By default, Comet runs a Spark-compatible implementation of `Lower`. Set `spark.comet.caseConversion.enabled=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Results can vary depending on locale and character set
+
 ## OctetLength
 
 The following cases are not supported by Comet:
 
 - `BinaryType` input is not supported
 
+## RLike
+
+By default, Comet runs a Spark-compatible implementation of `RLike`. Set `spark.comet.expression.RLike.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Uses Rust regexp engine, which has different behavior to Java regexp engine
+
+## RegExpReplace
+
+By default, Comet runs a Spark-compatible implementation of `RegExpReplace`. Set `spark.comet.expression.RegExpReplace.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Regexp pattern may not be compatible with Spark
+
 ## Reverse
 
-By default, Comet accelerates `Reverse` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.Reverse.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `Reverse`. Set `spark.comet.expression.Reverse.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - reverse on array containing binary is not supported
 - reverse does not support non-UTF8_BINARY collations (https://github.com/apache/datafusion-comet/issues/2190)
@@ -89,9 +119,27 @@ The following differences from Spark are always present and do not require any a
 
 - A negative argument for the number of times to repeat throws an exception instead of returning an empty string as Spark does
 
+## StringReplace
+
+By default, Comet runs a Spark-compatible implementation of `StringReplace`. Set `spark.comet.expression.StringReplace.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Produces different results from Spark when the search string is empty
+
+## StringSplit
+
+By default, Comet runs a Spark-compatible implementation of `StringSplit`. Set `spark.comet.expression.StringSplit.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Regex engine differences between Java and Rust
+
 ## StringTranslate
 
 The following incompatibilities cause `StringTranslate` to fall back to Spark by default. Set `spark.comet.expression.StringTranslate.allowIncompatible=true` to enable Comet acceleration despite these differences.
 
 - DataFusion's translate iterates over Unicode graphemes (Spark uses code points) and substitutes U+0000 instead of treating it as a deletion sentinel
+
+## Upper
+
+By default, Comet runs a Spark-compatible implementation of `Upper`. Set `spark.comet.caseConversion.enabled=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Results can vary depending on locale and character set
 <!--END:EXPR_COMPAT-->
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-4.0/struct.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-4.0/struct.md.txt
index 72db34d875..8c40efde43 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-4.0/struct.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-4.0/struct.md.txt
@@ -27,6 +27,12 @@ The following cases are not supported by Comet:
 
 - `CreateNamedStruct` with duplicate field names is not supported
 
+## JsonToStructs
+
+By default, Comet runs a Spark-compatible implementation of `JsonToStructs`. Set `spark.comet.expression.JsonToStructs.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Partially implemented and not comprehensively tested
+
 ## StructsToCsv
 
 The following incompatibilities cause `StructsToCsv` to fall back to Spark by default. Set `spark.comet.expression.StructsToCsv.allowIncompatible=true` to enable Comet acceleration despite these differences.
@@ -36,4 +42,10 @@ The following incompatibilities cause `StructsToCsv` to fall back to Spark by de
 The following cases are not supported by Comet:
 
 - Complex types (arrays, maps, structs) in the schema are not supported
+
+## StructsToJson
+
+By default, Comet runs a Spark-compatible implementation of `StructsToJson`. Set `spark.comet.expression.StructsToJson.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Does not support `+Infinity` and `-Infinity` for numeric types (float, double). (https://github.com/apache/datafusion-comet/issues/3016)
 <!--END:EXPR_COMPAT-->
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-4.1/array.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-4.1/array.md.txt
index 826397f55c..87c8c8f4e7 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-4.1/array.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-4.1/array.md.txt
@@ -23,13 +23,13 @@ under the License.
 
 ## ArrayExcept
 
-By default, Comet accelerates `ArrayExcept` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.ArrayExcept.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `ArrayExcept`. Set `spark.comet.expression.ArrayExcept.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Null handling and ordering may differ from Spark
 
 ## ArrayIntersect
 
-By default, Comet accelerates `ArrayIntersect` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.ArrayIntersect.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `ArrayIntersect`. Set `spark.comet.expression.ArrayIntersect.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Result array element order may differ from Spark when the right array is longer than the left (DataFusion probes the longer side).
 
@@ -39,7 +39,7 @@ The following cases are not supported by Comet:
 
 ## ArrayJoin
 
-By default, Comet accelerates `ArrayJoin` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.ArrayJoin.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `ArrayJoin`. Set `spark.comet.expression.ArrayJoin.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Null handling may differ from Spark
 
@@ -57,7 +57,7 @@ The following cases are not supported by Comet:
 
 ## SortArray
 
-By default, Comet accelerates `SortArray` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.SortArray.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `SortArray`. Set `spark.comet.expression.SortArray.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - When `spark.comet.exec.strictFloatingPoint=true`, sorting on floating-point types is not 100% compatible with Spark
 
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-4.1/datetime.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-4.1/datetime.md.txt
index 0cd0004d4c..09babb62c0 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-4.1/datetime.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-4.1/datetime.md.txt
@@ -46,7 +46,7 @@ If you need to process dates far in the future with accurate timezone handling,
 
 ## ConvertTimezone
 
-By default, Comet accelerates `ConvertTimezone` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.ConvertTimezone.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `ConvertTimezone`. Set `spark.comet.expression.ConvertTimezone.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Comet's native timezone parser only accepts IANA zone IDs (e.g. `America/Los_Angeles`) and fixed offsets in `+HH:MM` form. Spark also accepts forms such as `GMT+1`, `UTC+1`, or three-letter abbreviations like `PST`; queries using those forms will throw a native parse error at execution time. See https://github.com/apache/datafusion-comet/issues/2013.
 
@@ -56,6 +56,10 @@ The following differences from Spark are always present and do not require any a
 
 - Format strings in a curated allow-list run natively via DataFusion's `to_char` for UTC sessions. Other format strings (including non-literal formats), as well as non-UTC sessions, route through Spark's own `DateFormatClass.doGenCode` via the Arrow-direct codegen dispatcher when `spark.comet.exec.scalaUDF.codegen.enabled=true` (the default). When the codegen dispatcher is disabled the operator falls back to Spark in those cases.
 
+By default, Comet runs a Spark-compatible implementation of `DateFormatClass`. Set `spark.comet.expression.DateFormatClass.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Non-UTC timezones may produce different results than Spark
+
 ## Days
 
 The following cases are not supported by Comet:
@@ -64,19 +68,19 @@ The following cases are not supported by Comet:
 
 ## FromUTCTimestamp
 
-By default, Comet accelerates `FromUTCTimestamp` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.FromUTCTimestamp.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `FromUTCTimestamp`. Set `spark.comet.expression.FromUTCTimestamp.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Comet's native timezone parser only accepts IANA zone IDs (e.g. `America/Los_Angeles`) and fixed offsets in `+HH:MM` form. Spark also accepts forms such as `GMT+1`, `UTC+1`, or three-letter abbreviations like `PST`; queries using those forms will throw a native parse error at execution time. See https://github.com/apache/datafusion-comet/issues/2013.
 
 ## FromUnixTime
 
-By default, Comet accelerates `FromUnixTime` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.FromUnixTime.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `FromUnixTime`. Set `spark.comet.expression.FromUnixTime.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Only supports the default datetime format pattern `yyyy-MM-dd HH:mm:ss`. DataFusion's valid timestamp range differs from Spark (https://github.com/apache/datafusion/issues/16594)
 
 ## Hour
 
-By default, Comet accelerates `Hour` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.Hour.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `Hour`. Set `spark.comet.expression.Hour.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Incorrectly applies timezone conversion to TimestampNTZ inputs (https://github.com/apache/datafusion-comet/issues/3180)
 
@@ -88,13 +92,13 @@ The following cases are not supported by Comet:
 
 ## Minute
 
-By default, Comet accelerates `Minute` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.Minute.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `Minute`. Set `spark.comet.expression.Minute.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Incorrectly applies timezone conversion to TimestampNTZ inputs (https://github.com/apache/datafusion-comet/issues/3180)
 
 ## Second
 
-By default, Comet accelerates `Second` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.Second.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `Second`. Set `spark.comet.expression.Second.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Incorrectly applies timezone conversion to TimestampNTZ inputs (https://github.com/apache/datafusion-comet/issues/3180)
 
@@ -106,13 +110,13 @@ The following cases are not supported by Comet:
 
 ## ToUTCTimestamp
 
-By default, Comet accelerates `ToUTCTimestamp` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.ToUTCTimestamp.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `ToUTCTimestamp`. Set `spark.comet.expression.ToUTCTimestamp.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Comet's native timezone parser only accepts IANA zone IDs (e.g. `America/Los_Angeles`) and fixed offsets in `+HH:MM` form. Spark also accepts forms such as `GMT+1`, `UTC+1`, or three-letter abbreviations like `PST`; queries using those forms will throw a native parse error at execution time. See https://github.com/apache/datafusion-comet/issues/2013.
 
 ## TruncDate
 
-By default, Comet accelerates `TruncDate` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.TruncDate.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `TruncDate`. Set `spark.comet.expression.TruncDate.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Non-literal format strings will throw an exception instead of returning NULL
 
@@ -122,7 +126,7 @@ The following cases are not supported by Comet:
 
 ## TruncTimestamp
 
-By default, Comet accelerates `TruncTimestamp` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.TruncTimestamp.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `TruncTimestamp`. Set `spark.comet.expression.TruncTimestamp.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - Produces incorrect results when used with non-UTC timezones. Compatible when timezone is UTC. (https://github.com/apache/datafusion-comet/issues/2649)
 - Non-literal format strings will throw an exception instead of returning NULL
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-4.1/map.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-4.1/map.md.txt
index 88840c0bc6..0595249b1a 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-4.1/map.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-4.1/map.md.txt
@@ -34,7 +34,7 @@ IEEE total ordering for floating-point, which differs from Spark's `Double.compa
 
 ## MapFromEntries
 
-By default, Comet accelerates `MapFromEntries` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.MapFromEntries.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `MapFromEntries`. Set `spark.comet.expression.MapFromEntries.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - `BinaryType` is not supported as a map key in `map_from_entries`
 - `BinaryType` is not supported as a map value in `map_from_entries`
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-4.1/string.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-4.1/string.md.txt
index a75b2cbca9..f20f499070 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-4.1/string.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-4.1/string.md.txt
@@ -29,7 +29,7 @@ The following cases are not supported by Comet:
 
 ## Concat
 
-By default, Comet accelerates `Concat` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.Concat.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `Concat`. Set `spark.comet.expression.Concat.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - concat does not support non-UTF8_BINARY collations (https://github.com/apache/datafusion-comet/issues/2190)
 
@@ -37,6 +37,18 @@ The following cases are not supported by Comet:
 
 - CONCAT supports only string input parameters
 
+## GetJsonObject
+
+By default, Comet runs a Spark-compatible implementation of `GetJsonObject`. Set `spark.comet.expression.GetJsonObject.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Spark allows single-quoted JSON and unescaped control characters which Comet does not support
+
+## InitCap
+
+By default, Comet runs a Spark-compatible implementation of `InitCap`. Set `spark.comet.expression.InitCap.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Treats hyphen as a word separator (e.g. `robert rose-smith` produces `Robert Rose-Smith` instead of Spark's `Robert Rose-smith`) (https://github.com/apache/datafusion-comet/issues/1052)
+
 ## Left
 
 The following cases are not supported by Comet:
@@ -50,15 +62,33 @@ The following cases are not supported by Comet:
 
 - `BinaryType` input is not supported
 
+## Lower
+
+By default, Comet runs a Spark-compatible implementation of `Lower`. Set `spark.comet.caseConversion.enabled=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Results can vary depending on locale and character set
+
 ## OctetLength
 
 The following cases are not supported by Comet:
 
 - `BinaryType` input is not supported
 
+## RLike
+
+By default, Comet runs a Spark-compatible implementation of `RLike`. Set `spark.comet.expression.RLike.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Uses Rust regexp engine, which has different behavior to Java regexp engine
+
+## RegExpReplace
+
+By default, Comet runs a Spark-compatible implementation of `RegExpReplace`. Set `spark.comet.expression.RegExpReplace.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Regexp pattern may not be compatible with Spark
+
 ## Reverse
 
-By default, Comet accelerates `Reverse` using JVM codegen dispatch, which runs Spark's generated code inside Comet's native pipeline and matches Spark exactly. Set `spark.comet.expression.Reverse.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+By default, Comet runs a Spark-compatible implementation of `Reverse`. Set `spark.comet.expression.Reverse.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
 
 - reverse on array containing binary is not supported
 - reverse does not support non-UTF8_BINARY collations (https://github.com/apache/datafusion-comet/issues/2190)
@@ -89,9 +119,27 @@ The following differences from Spark are always present and do not require any a
 
 - A negative argument for the number of times to repeat throws an exception instead of returning an empty string as Spark does
 
+## StringReplace
+
+By default, Comet runs a Spark-compatible implementation of `StringReplace`. Set `spark.comet.expression.StringReplace.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Produces different results from Spark when the search string is empty
+
+## StringSplit
+
+By default, Comet runs a Spark-compatible implementation of `StringSplit`. Set `spark.comet.expression.StringSplit.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Regex engine differences between Java and Rust
+
 ## StringTranslate
 
 The following incompatibilities cause `StringTranslate` to fall back to Spark by default. Set `spark.comet.expression.StringTranslate.allowIncompatible=true` to enable Comet acceleration despite these differences.
 
 - DataFusion's translate iterates over Unicode graphemes (Spark uses code points) and substitutes U+0000 instead of treating it as a deletion sentinel
+
+## Upper
+
+By default, Comet runs a Spark-compatible implementation of `Upper`. Set `spark.comet.caseConversion.enabled=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Results can vary depending on locale and character set
 <!--END:EXPR_COMPAT-->
diff --git a/_sources/user-guide/latest/compatibility/expressions/spark-4.1/struct.md.txt b/_sources/user-guide/latest/compatibility/expressions/spark-4.1/struct.md.txt
index 72db34d875..8c40efde43 100644
--- a/_sources/user-guide/latest/compatibility/expressions/spark-4.1/struct.md.txt
+++ b/_sources/user-guide/latest/compatibility/expressions/spark-4.1/struct.md.txt
@@ -27,6 +27,12 @@ The following cases are not supported by Comet:
 
 - `CreateNamedStruct` with duplicate field names is not supported
 
+## JsonToStructs
+
+By default, Comet runs a Spark-compatible implementation of `JsonToStructs`. Set `spark.comet.expression.JsonToStructs.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Partially implemented and not comprehensively tested
+
 ## StructsToCsv
 
 The following incompatibilities cause `StructsToCsv` to fall back to Spark by default. Set `spark.comet.expression.StructsToCsv.allowIncompatible=true` to enable Comet acceleration despite these differences.
@@ -36,4 +42,10 @@ The following incompatibilities cause `StructsToCsv` to fall back to Spark by de
 The following cases are not supported by Comet:
 
 - Complex types (arrays, maps, structs) in the schema are not supported
+
+## StructsToJson
+
+By default, Comet runs a Spark-compatible implementation of `StructsToJson`. Set `spark.comet.expression.StructsToJson.allowIncompatible=true` to use Comet's faster native implementation instead, which has the following differences from Spark:
+
+- Does not support `+Infinity` and `-Infinity` for numeric types (float, double). (https://github.com/apache/datafusion-comet/issues/3016)
 <!--END:EXPR_COMPAT-->
diff --git a/_sources/user-guide/latest/compatibility/index.md.txt b/_sources/user-guide/latest/compatibility/index.md.txt
index 54a7b4ae39..f3b531a18f 100644
--- a/_sources/user-guide/latest/compatibility/index.md.txt
+++ b/_sources/user-guide/latest/compatibility/index.md.txt
@@ -31,6 +31,19 @@ This guide documents areas where Comet's behavior is known to differ from Spark.
 - **JSON**: choosing between the native and Spark-compatible engines for JSON expressions.
 - **Spark versions**: version-specific known issues and limitations.
 
+## Compatible by default, opt in to native
+
+Comet runs a Spark-compatible implementation of every supported expression by default. Some
+expressions also have a faster native implementation that can differ from Spark for certain
+inputs. These are not used unless you opt in by setting the relevant
+`spark.comet.expression.<Name>.allowIncompatible=true` config (a few use a dedicated config, noted
+per expression below), after which you accept the documented differences.
+
+You can discover where a native opt-in is available for a specific query in the verbose extended
+explain output. A `[COMET-INFO: ...]` segment points at an available native path and does not mean
+the operator falls back to Spark. This is distinct from `[COMET: ...]`, which records a reason an
+operator did fall back.
+
 ## Native and codegen-dispatch implementations
 
 Some Spark expressions have two implementations in Comet:
diff --git a/searchindex.js b/searchindex.js
index e5850a234a..a1402e4b01 100644
--- a/searchindex.js
+++ b/searchindex.js
@@ -1 +1 @@
-Search.setIndex({"alltitles": {"!": [[50, "id1"]], "%": [[48, "id1"]], "&": [[38, "id1"]], "*": [[48, "id2"]], "+": [[48, "id3"]], "-": [[48, "id4"]], "/": [[48, "id5"]], "1. Format Your Code": [[35, "format-your-code"]], "1. Install Comet": [[56, "install-comet"], [65, "install-comet"]], "1. Native Operators (nativeExecs map)": [[24, "native-operators-nativeexecs-map"]], "2. Build and Verify": [[35, "build-and-verify"]], "2. Clone Iceberg and Apply Diff": [[56, "clone-iceberg-and-apply- [...]
\ No newline at end of file
+Search.setIndex({"alltitles": {"!": [[50, "id1"]], "%": [[48, "id1"]], "&": [[38, "id1"]], "*": [[48, "id2"]], "+": [[48, "id3"]], "-": [[48, "id4"]], "/": [[48, "id5"]], "1. Format Your Code": [[35, "format-your-code"]], "1. Install Comet": [[56, "install-comet"], [65, "install-comet"]], "1. Native Operators (nativeExecs map)": [[24, "native-operators-nativeexecs-map"]], "2. Build and Verify": [[35, "build-and-verify"]], "2. Clone Iceberg and Apply Diff": [[56, "clone-iceberg-and-apply- [...]
\ No newline at end of file
diff --git a/user-guide/latest/compatibility/expressions/spark-3.4/array.html b/user-guide/latest/compatibility/expressions/spark-3.4/array.html
index d0619434b9..36448e7b7a 100644
--- a/user-guide/latest/compatibility/expressions/spark-3.4/array.html
+++ b/user-guide/latest/compatibility/expressions/spark-3.4/array.html
@@ -577,14 +577,14 @@ under the License.
 <!--BEGIN:EXPR_COMPAT[array]-->
 <section id="arrayexcept">
 <h2>ArrayExcept<a class="headerlink" href="#arrayexcept" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">ArrayExcept</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayExcept.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">ArrayExcept</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayExcept.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Null handling and ordering may differ from Spark</p></li>
 </ul>
 </section>
 <section id="arrayintersect">
 <h2>ArrayIntersect<a class="headerlink" href="#arrayintersect" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">ArrayIntersect</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayIntersect.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">ArrayIntersect</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayIntersect.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Result array element order may differ from Spark when the right array is longer than the left (DataFusion probes the longer side).</p></li>
 </ul>
@@ -595,7 +595,7 @@ under the License.
 </section>
 <section id="arrayjoin">
 <h2>ArrayJoin<a class="headerlink" href="#arrayjoin" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">ArrayJoin</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayJoin.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">ArrayJoin</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayJoin.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Null handling may differ from Spark</p></li>
 </ul>
@@ -616,7 +616,7 @@ under the License.
 </section>
 <section id="sortarray">
 <h2>SortArray<a class="headerlink" href="#sortarray" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">SortArray</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.SortArray.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">SortArray</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.SortArray.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</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>
 </ul>
diff --git a/user-guide/latest/compatibility/expressions/spark-3.4/datetime.html b/user-guide/latest/compatibility/expressions/spark-3.4/datetime.html
index 49f26d52fe..3fa6c07347 100644
--- a/user-guide/latest/compatibility/expressions/spark-3.4/datetime.html
+++ b/user-guide/latest/compatibility/expressions/spark-3.4/datetime.html
@@ -600,7 +600,7 @@ with Spark. For dates beyond this range, functions that involve timezone-aware c
 </section>
 <section id="converttimezone">
 <h2>ConvertTimezone<a class="headerlink" href="#converttimezone" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">ConvertTimezone</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ConvertTimezone.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">ConvertTimezone</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ConvertTimezone.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Comet’s native timezone parser only accepts IANA zone IDs (e.g. <code class="docutils literal notranslate"><span class="pre">America/Los_Angeles</span></code>) and fixed offsets in <code class="docutils literal notranslate"><span class="pre">+HH:MM</span></code> form. Spark also accepts forms such as <code class="docutils literal notranslate"><span class="pre">GMT+1</span></code>, <code class="docutils literal notranslate"><span class="pre">UTC+1</span></code>, or three-letter abb [...]
 </ul>
@@ -611,6 +611,10 @@ with Spark. For dates beyond this range, functions that involve timezone-aware c
 <ul class="simple">
 <li><p>Format strings in a curated allow-list run natively via DataFusion’s <code class="docutils literal notranslate"><span class="pre">to_char</span></code> for UTC sessions. Other format strings (including non-literal formats), as well as non-UTC sessions, route through Spark’s own <code class="docutils literal notranslate"><span class="pre">DateFormatClass.doGenCode</span></code> via the Arrow-direct codegen dispatcher when <code class="docutils literal notranslate"><span class="pre" [...]
 </ul>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">DateFormatClass</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.DateFormatClass.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Non-UTC timezones may produce different results than Spark</p></li>
+</ul>
 </section>
 <section id="days">
 <h2>Days<a class="headerlink" href="#days" title="Link to this heading">#</a></h2>
@@ -621,21 +625,21 @@ with Spark. For dates beyond this range, functions that involve timezone-aware c
 </section>
 <section id="fromutctimestamp">
 <h2>FromUTCTimestamp<a class="headerlink" href="#fromutctimestamp" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">FromUTCTimestamp</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.FromUTCTimestamp.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">FromUTCTimestamp</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.FromUTCTimestamp.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Comet’s native timezone parser only accepts IANA zone IDs (e.g. <code class="docutils literal notranslate"><span class="pre">America/Los_Angeles</span></code>) and fixed offsets in <code class="docutils literal notranslate"><span class="pre">+HH:MM</span></code> form. Spark also accepts forms such as <code class="docutils literal notranslate"><span class="pre">GMT+1</span></code>, <code class="docutils literal notranslate"><span class="pre">UTC+1</span></code>, or three-letter abb [...]
 </ul>
 </section>
 <section id="fromunixtime">
 <h2>FromUnixTime<a class="headerlink" href="#fromunixtime" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">FromUnixTime</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.FromUnixTime.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">FromUnixTime</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.FromUnixTime.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Only supports the default datetime format pattern <code class="docutils literal notranslate"><span class="pre">yyyy-MM-dd</span> <span class="pre">HH:mm:ss</span></code>. DataFusion’s valid timestamp range differs from Spark (https://github.com/apache/datafusion/issues/16594)</p></li>
 </ul>
 </section>
 <section id="hour">
 <h2>Hour<a class="headerlink" href="#hour" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">Hour</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Hour.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Hour</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Hour.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Incorrectly applies timezone conversion to TimestampNTZ inputs (https://github.com/apache/datafusion-comet/issues/3180)</p></li>
 </ul>
@@ -649,14 +653,14 @@ with Spark. For dates beyond this range, functions that involve timezone-aware c
 </section>
 <section id="minute">
 <h2>Minute<a class="headerlink" href="#minute" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">Minute</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Minute.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Minute</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Minute.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Incorrectly applies timezone conversion to TimestampNTZ inputs (https://github.com/apache/datafusion-comet/issues/3180)</p></li>
 </ul>
 </section>
 <section id="second">
 <h2>Second<a class="headerlink" href="#second" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">Second</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Second.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Second</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Second.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Incorrectly applies timezone conversion to TimestampNTZ inputs (https://github.com/apache/datafusion-comet/issues/3180)</p></li>
 </ul>
@@ -670,14 +674,14 @@ with Spark. For dates beyond this range, functions that involve timezone-aware c
 </section>
 <section id="toutctimestamp">
 <h2>ToUTCTimestamp<a class="headerlink" href="#toutctimestamp" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">ToUTCTimestamp</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ToUTCTimestamp.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">ToUTCTimestamp</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ToUTCTimestamp.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Comet’s native timezone parser only accepts IANA zone IDs (e.g. <code class="docutils literal notranslate"><span class="pre">America/Los_Angeles</span></code>) and fixed offsets in <code class="docutils literal notranslate"><span class="pre">+HH:MM</span></code> form. Spark also accepts forms such as <code class="docutils literal notranslate"><span class="pre">GMT+1</span></code>, <code class="docutils literal notranslate"><span class="pre">UTC+1</span></code>, or three-letter abb [...]
 </ul>
 </section>
 <section id="truncdate">
 <h2>TruncDate<a class="headerlink" href="#truncdate" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">TruncDate</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.TruncDate.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">TruncDate</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.TruncDate.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Non-literal format strings will throw an exception instead of returning NULL</p></li>
 </ul>
@@ -688,7 +692,7 @@ with Spark. For dates beyond this range, functions that involve timezone-aware c
 </section>
 <section id="trunctimestamp">
 <h2>TruncTimestamp<a class="headerlink" href="#trunctimestamp" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">TruncTimestamp</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.TruncTimestamp.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">TruncTimestamp</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.TruncTimestamp.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Produces incorrect results when used with non-UTC timezones. Compatible when timezone is UTC. (https://github.com/apache/datafusion-comet/issues/2649)</p></li>
 <li><p>Non-literal format strings will throw an exception instead of returning NULL</p></li>
diff --git a/user-guide/latest/compatibility/expressions/spark-3.4/map.html b/user-guide/latest/compatibility/expressions/spark-3.4/map.html
index 69e78ede3b..ee4cf3c391 100644
--- a/user-guide/latest/compatibility/expressions/spark-3.4/map.html
+++ b/user-guide/latest/compatibility/expressions/spark-3.4/map.html
@@ -587,7 +587,7 @@ IEEE total ordering for floating-point, which differs from Spark’s <code class
 </section>
 <section id="mapfromentries">
 <h2>MapFromEntries<a class="headerlink" href="#mapfromentries" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">MapFromEntries</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.MapFromEntries.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">MapFromEntries</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.MapFromEntries.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p><code class="docutils literal notranslate"><span class="pre">BinaryType</span></code> is not supported as a map key in <code class="docutils literal notranslate"><span class="pre">map_from_entries</span></code></p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">BinaryType</span></code> is not supported as a map value in <code class="docutils literal notranslate"><span class="pre">map_from_entries</span></code></p></li>
diff --git a/user-guide/latest/compatibility/expressions/spark-3.4/string.html b/user-guide/latest/compatibility/expressions/spark-3.4/string.html
index 515c8c41fa..dc9c756555 100644
--- a/user-guide/latest/compatibility/expressions/spark-3.4/string.html
+++ b/user-guide/latest/compatibility/expressions/spark-3.4/string.html
@@ -584,7 +584,7 @@ under the License.
 </section>
 <section id="concat">
 <h2>Concat<a class="headerlink" href="#concat" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">Concat</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Concat.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Concat</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Concat.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>concat does not support non-UTF8_BINARY collations (https://github.com/apache/datafusion-comet/issues/2190)</p></li>
 </ul>
@@ -593,6 +593,20 @@ under the License.
 <li><p>CONCAT supports only string input parameters</p></li>
 </ul>
 </section>
+<section id="getjsonobject">
+<h2>GetJsonObject<a class="headerlink" href="#getjsonobject" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">GetJsonObject</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.GetJsonObject.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Spark allows single-quoted JSON and unescaped control characters which Comet does not support</p></li>
+</ul>
+</section>
+<section id="initcap">
+<h2>InitCap<a class="headerlink" href="#initcap" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">InitCap</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.InitCap.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Treats hyphen as a word separator (e.g. <code class="docutils literal notranslate"><span class="pre">robert</span> <span class="pre">rose-smith</span></code> produces <code class="docutils literal notranslate"><span class="pre">Robert</span> <span class="pre">Rose-Smith</span></code> instead of Spark’s <code class="docutils literal notranslate"><span class="pre">Robert</span> <span class="pre">Rose-smith</span></code>) (https://github.com/apache/datafusion-comet/issues/1052)</p></li>
+</ul>
+</section>
 <section id="left">
 <h2>Left<a class="headerlink" href="#left" title="Link to this heading">#</a></h2>
 <p>The following cases are not supported by Comet:</p>
@@ -608,6 +622,13 @@ under the License.
 <li><p><code class="docutils literal notranslate"><span class="pre">BinaryType</span></code> input is not supported</p></li>
 </ul>
 </section>
+<section id="lower">
+<h2>Lower<a class="headerlink" href="#lower" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Lower</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.caseConversion.enabled=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Results can vary depending on locale and character set</p></li>
+</ul>
+</section>
 <section id="octetlength">
 <h2>OctetLength<a class="headerlink" href="#octetlength" title="Link to this heading">#</a></h2>
 <p>The following cases are not supported by Comet:</p>
@@ -615,9 +636,23 @@ under the License.
 <li><p><code class="docutils literal notranslate"><span class="pre">BinaryType</span></code> input is not supported</p></li>
 </ul>
 </section>
+<section id="rlike">
+<h2>RLike<a class="headerlink" href="#rlike" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">RLike</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RLike.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Uses Rust regexp engine, which has different behavior to Java regexp engine</p></li>
+</ul>
+</section>
+<section id="regexpreplace">
+<h2>RegExpReplace<a class="headerlink" href="#regexpreplace" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">RegExpReplace</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegExpReplace.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Regexp pattern may not be compatible with Spark</p></li>
+</ul>
+</section>
 <section id="reverse">
 <h2>Reverse<a class="headerlink" href="#reverse" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">Reverse</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Reverse.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Reverse</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Reverse.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>reverse on array containing binary is not supported</p></li>
 <li><p>reverse does not support non-UTF8_BINARY collations (https://github.com/apache/datafusion-comet/issues/2190)</p></li>
@@ -653,12 +688,33 @@ under the License.
 <li><p>A negative argument for the number of times to repeat throws an exception instead of returning an empty string as Spark does</p></li>
 </ul>
 </section>
+<section id="stringreplace">
+<h2>StringReplace<a class="headerlink" href="#stringreplace" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">StringReplace</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.StringReplace.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Produces different results from Spark when the search string is empty</p></li>
+</ul>
+</section>
+<section id="stringsplit">
+<h2>StringSplit<a class="headerlink" href="#stringsplit" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">StringSplit</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.StringSplit.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Regex engine differences between Java and Rust</p></li>
+</ul>
+</section>
 <section id="stringtranslate">
 <h2>StringTranslate<a class="headerlink" href="#stringtranslate" title="Link to this heading">#</a></h2>
 <p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">StringTranslate</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.StringTranslate.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
 <ul class="simple">
 <li><p>DataFusion’s translate iterates over Unicode graphemes (Spark uses code points) and substitutes U+0000 instead of treating it as a deletion sentinel</p></li>
 </ul>
+</section>
+<section id="upper">
+<h2>Upper<a class="headerlink" href="#upper" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Upper</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.caseConversion.enabled=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Results can vary depending on locale and character set</p></li>
+</ul>
 <!--END:EXPR_COMPAT-->
 </section>
 </section>
diff --git a/user-guide/latest/compatibility/expressions/spark-3.4/struct.html b/user-guide/latest/compatibility/expressions/spark-3.4/struct.html
index a9ed2432da..fb45ca3c3f 100644
--- a/user-guide/latest/compatibility/expressions/spark-3.4/struct.html
+++ b/user-guide/latest/compatibility/expressions/spark-3.4/struct.html
@@ -582,6 +582,13 @@ under the License.
 <li><p><code class="docutils literal notranslate"><span class="pre">CreateNamedStruct</span></code> with duplicate field names is not supported</p></li>
 </ul>
 </section>
+<section id="jsontostructs">
+<h2>JsonToStructs<a class="headerlink" href="#jsontostructs" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">JsonToStructs</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.JsonToStructs.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Partially implemented and not comprehensively tested</p></li>
+</ul>
+</section>
 <section id="structstocsv">
 <h2>StructsToCsv<a class="headerlink" href="#structstocsv" title="Link to this heading">#</a></h2>
 <p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">StructsToCsv</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.StructsToCsv.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
@@ -592,6 +599,13 @@ under the License.
 <ul class="simple">
 <li><p>Complex types (arrays, maps, structs) in the schema are not supported</p></li>
 </ul>
+</section>
+<section id="structstojson">
+<h2>StructsToJson<a class="headerlink" href="#structstojson" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">StructsToJson</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.StructsToJson.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Does not support <code class="docutils literal notranslate"><span class="pre">+Infinity</span></code> and <code class="docutils literal notranslate"><span class="pre">-Infinity</span></code> for numeric types (float, double). (https://github.com/apache/datafusion-comet/issues/3016)</p></li>
+</ul>
 <!--END:EXPR_COMPAT-->
 </section>
 </section>
diff --git a/user-guide/latest/compatibility/expressions/spark-3.5/array.html b/user-guide/latest/compatibility/expressions/spark-3.5/array.html
index ee5dd30730..a279575620 100644
--- a/user-guide/latest/compatibility/expressions/spark-3.5/array.html
+++ b/user-guide/latest/compatibility/expressions/spark-3.5/array.html
@@ -577,14 +577,14 @@ under the License.
 <!--BEGIN:EXPR_COMPAT[array]-->
 <section id="arrayexcept">
 <h2>ArrayExcept<a class="headerlink" href="#arrayexcept" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">ArrayExcept</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayExcept.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">ArrayExcept</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayExcept.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Null handling and ordering may differ from Spark</p></li>
 </ul>
 </section>
 <section id="arrayintersect">
 <h2>ArrayIntersect<a class="headerlink" href="#arrayintersect" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">ArrayIntersect</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayIntersect.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">ArrayIntersect</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayIntersect.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Result array element order may differ from Spark when the right array is longer than the left (DataFusion probes the longer side).</p></li>
 </ul>
@@ -595,7 +595,7 @@ under the License.
 </section>
 <section id="arrayjoin">
 <h2>ArrayJoin<a class="headerlink" href="#arrayjoin" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">ArrayJoin</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayJoin.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">ArrayJoin</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayJoin.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Null handling may differ from Spark</p></li>
 </ul>
@@ -616,7 +616,7 @@ under the License.
 </section>
 <section id="sortarray">
 <h2>SortArray<a class="headerlink" href="#sortarray" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">SortArray</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.SortArray.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">SortArray</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.SortArray.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</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>
 </ul>
diff --git a/user-guide/latest/compatibility/expressions/spark-3.5/datetime.html b/user-guide/latest/compatibility/expressions/spark-3.5/datetime.html
index 2ae29e2989..af84842bbb 100644
--- a/user-guide/latest/compatibility/expressions/spark-3.5/datetime.html
+++ b/user-guide/latest/compatibility/expressions/spark-3.5/datetime.html
@@ -600,7 +600,7 @@ with Spark. For dates beyond this range, functions that involve timezone-aware c
 </section>
 <section id="converttimezone">
 <h2>ConvertTimezone<a class="headerlink" href="#converttimezone" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">ConvertTimezone</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ConvertTimezone.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">ConvertTimezone</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ConvertTimezone.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Comet’s native timezone parser only accepts IANA zone IDs (e.g. <code class="docutils literal notranslate"><span class="pre">America/Los_Angeles</span></code>) and fixed offsets in <code class="docutils literal notranslate"><span class="pre">+HH:MM</span></code> form. Spark also accepts forms such as <code class="docutils literal notranslate"><span class="pre">GMT+1</span></code>, <code class="docutils literal notranslate"><span class="pre">UTC+1</span></code>, or three-letter abb [...]
 </ul>
@@ -611,6 +611,10 @@ with Spark. For dates beyond this range, functions that involve timezone-aware c
 <ul class="simple">
 <li><p>Format strings in a curated allow-list run natively via DataFusion’s <code class="docutils literal notranslate"><span class="pre">to_char</span></code> for UTC sessions. Other format strings (including non-literal formats), as well as non-UTC sessions, route through Spark’s own <code class="docutils literal notranslate"><span class="pre">DateFormatClass.doGenCode</span></code> via the Arrow-direct codegen dispatcher when <code class="docutils literal notranslate"><span class="pre" [...]
 </ul>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">DateFormatClass</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.DateFormatClass.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Non-UTC timezones may produce different results than Spark</p></li>
+</ul>
 </section>
 <section id="days">
 <h2>Days<a class="headerlink" href="#days" title="Link to this heading">#</a></h2>
@@ -621,21 +625,21 @@ with Spark. For dates beyond this range, functions that involve timezone-aware c
 </section>
 <section id="fromutctimestamp">
 <h2>FromUTCTimestamp<a class="headerlink" href="#fromutctimestamp" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">FromUTCTimestamp</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.FromUTCTimestamp.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">FromUTCTimestamp</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.FromUTCTimestamp.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Comet’s native timezone parser only accepts IANA zone IDs (e.g. <code class="docutils literal notranslate"><span class="pre">America/Los_Angeles</span></code>) and fixed offsets in <code class="docutils literal notranslate"><span class="pre">+HH:MM</span></code> form. Spark also accepts forms such as <code class="docutils literal notranslate"><span class="pre">GMT+1</span></code>, <code class="docutils literal notranslate"><span class="pre">UTC+1</span></code>, or three-letter abb [...]
 </ul>
 </section>
 <section id="fromunixtime">
 <h2>FromUnixTime<a class="headerlink" href="#fromunixtime" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">FromUnixTime</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.FromUnixTime.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">FromUnixTime</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.FromUnixTime.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Only supports the default datetime format pattern <code class="docutils literal notranslate"><span class="pre">yyyy-MM-dd</span> <span class="pre">HH:mm:ss</span></code>. DataFusion’s valid timestamp range differs from Spark (https://github.com/apache/datafusion/issues/16594)</p></li>
 </ul>
 </section>
 <section id="hour">
 <h2>Hour<a class="headerlink" href="#hour" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">Hour</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Hour.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Hour</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Hour.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Incorrectly applies timezone conversion to TimestampNTZ inputs (https://github.com/apache/datafusion-comet/issues/3180)</p></li>
 </ul>
@@ -649,14 +653,14 @@ with Spark. For dates beyond this range, functions that involve timezone-aware c
 </section>
 <section id="minute">
 <h2>Minute<a class="headerlink" href="#minute" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">Minute</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Minute.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Minute</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Minute.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Incorrectly applies timezone conversion to TimestampNTZ inputs (https://github.com/apache/datafusion-comet/issues/3180)</p></li>
 </ul>
 </section>
 <section id="second">
 <h2>Second<a class="headerlink" href="#second" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">Second</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Second.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Second</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Second.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Incorrectly applies timezone conversion to TimestampNTZ inputs (https://github.com/apache/datafusion-comet/issues/3180)</p></li>
 </ul>
@@ -670,14 +674,14 @@ with Spark. For dates beyond this range, functions that involve timezone-aware c
 </section>
 <section id="toutctimestamp">
 <h2>ToUTCTimestamp<a class="headerlink" href="#toutctimestamp" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">ToUTCTimestamp</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ToUTCTimestamp.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">ToUTCTimestamp</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ToUTCTimestamp.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Comet’s native timezone parser only accepts IANA zone IDs (e.g. <code class="docutils literal notranslate"><span class="pre">America/Los_Angeles</span></code>) and fixed offsets in <code class="docutils literal notranslate"><span class="pre">+HH:MM</span></code> form. Spark also accepts forms such as <code class="docutils literal notranslate"><span class="pre">GMT+1</span></code>, <code class="docutils literal notranslate"><span class="pre">UTC+1</span></code>, or three-letter abb [...]
 </ul>
 </section>
 <section id="truncdate">
 <h2>TruncDate<a class="headerlink" href="#truncdate" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">TruncDate</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.TruncDate.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">TruncDate</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.TruncDate.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Non-literal format strings will throw an exception instead of returning NULL</p></li>
 </ul>
@@ -688,7 +692,7 @@ with Spark. For dates beyond this range, functions that involve timezone-aware c
 </section>
 <section id="trunctimestamp">
 <h2>TruncTimestamp<a class="headerlink" href="#trunctimestamp" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">TruncTimestamp</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.TruncTimestamp.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">TruncTimestamp</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.TruncTimestamp.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Produces incorrect results when used with non-UTC timezones. Compatible when timezone is UTC. (https://github.com/apache/datafusion-comet/issues/2649)</p></li>
 <li><p>Non-literal format strings will throw an exception instead of returning NULL</p></li>
diff --git a/user-guide/latest/compatibility/expressions/spark-3.5/map.html b/user-guide/latest/compatibility/expressions/spark-3.5/map.html
index 115f3c5fe5..23b6138e1d 100644
--- a/user-guide/latest/compatibility/expressions/spark-3.5/map.html
+++ b/user-guide/latest/compatibility/expressions/spark-3.5/map.html
@@ -587,7 +587,7 @@ IEEE total ordering for floating-point, which differs from Spark’s <code class
 </section>
 <section id="mapfromentries">
 <h2>MapFromEntries<a class="headerlink" href="#mapfromentries" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">MapFromEntries</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.MapFromEntries.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">MapFromEntries</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.MapFromEntries.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p><code class="docutils literal notranslate"><span class="pre">BinaryType</span></code> is not supported as a map key in <code class="docutils literal notranslate"><span class="pre">map_from_entries</span></code></p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">BinaryType</span></code> is not supported as a map value in <code class="docutils literal notranslate"><span class="pre">map_from_entries</span></code></p></li>
diff --git a/user-guide/latest/compatibility/expressions/spark-3.5/string.html b/user-guide/latest/compatibility/expressions/spark-3.5/string.html
index a2a7c12e64..7418c432a2 100644
--- a/user-guide/latest/compatibility/expressions/spark-3.5/string.html
+++ b/user-guide/latest/compatibility/expressions/spark-3.5/string.html
@@ -584,7 +584,7 @@ under the License.
 </section>
 <section id="concat">
 <h2>Concat<a class="headerlink" href="#concat" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">Concat</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Concat.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Concat</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Concat.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>concat does not support non-UTF8_BINARY collations (https://github.com/apache/datafusion-comet/issues/2190)</p></li>
 </ul>
@@ -593,6 +593,20 @@ under the License.
 <li><p>CONCAT supports only string input parameters</p></li>
 </ul>
 </section>
+<section id="getjsonobject">
+<h2>GetJsonObject<a class="headerlink" href="#getjsonobject" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">GetJsonObject</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.GetJsonObject.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Spark allows single-quoted JSON and unescaped control characters which Comet does not support</p></li>
+</ul>
+</section>
+<section id="initcap">
+<h2>InitCap<a class="headerlink" href="#initcap" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">InitCap</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.InitCap.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Treats hyphen as a word separator (e.g. <code class="docutils literal notranslate"><span class="pre">robert</span> <span class="pre">rose-smith</span></code> produces <code class="docutils literal notranslate"><span class="pre">Robert</span> <span class="pre">Rose-Smith</span></code> instead of Spark’s <code class="docutils literal notranslate"><span class="pre">Robert</span> <span class="pre">Rose-smith</span></code>) (https://github.com/apache/datafusion-comet/issues/1052)</p></li>
+</ul>
+</section>
 <section id="left">
 <h2>Left<a class="headerlink" href="#left" title="Link to this heading">#</a></h2>
 <p>The following cases are not supported by Comet:</p>
@@ -608,6 +622,13 @@ under the License.
 <li><p><code class="docutils literal notranslate"><span class="pre">BinaryType</span></code> input is not supported</p></li>
 </ul>
 </section>
+<section id="lower">
+<h2>Lower<a class="headerlink" href="#lower" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Lower</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.caseConversion.enabled=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Results can vary depending on locale and character set</p></li>
+</ul>
+</section>
 <section id="octetlength">
 <h2>OctetLength<a class="headerlink" href="#octetlength" title="Link to this heading">#</a></h2>
 <p>The following cases are not supported by Comet:</p>
@@ -615,9 +636,23 @@ under the License.
 <li><p><code class="docutils literal notranslate"><span class="pre">BinaryType</span></code> input is not supported</p></li>
 </ul>
 </section>
+<section id="rlike">
+<h2>RLike<a class="headerlink" href="#rlike" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">RLike</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RLike.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Uses Rust regexp engine, which has different behavior to Java regexp engine</p></li>
+</ul>
+</section>
+<section id="regexpreplace">
+<h2>RegExpReplace<a class="headerlink" href="#regexpreplace" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">RegExpReplace</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegExpReplace.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Regexp pattern may not be compatible with Spark</p></li>
+</ul>
+</section>
 <section id="reverse">
 <h2>Reverse<a class="headerlink" href="#reverse" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">Reverse</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Reverse.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Reverse</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Reverse.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>reverse on array containing binary is not supported</p></li>
 <li><p>reverse does not support non-UTF8_BINARY collations (https://github.com/apache/datafusion-comet/issues/2190)</p></li>
@@ -653,12 +688,33 @@ under the License.
 <li><p>A negative argument for the number of times to repeat throws an exception instead of returning an empty string as Spark does</p></li>
 </ul>
 </section>
+<section id="stringreplace">
+<h2>StringReplace<a class="headerlink" href="#stringreplace" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">StringReplace</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.StringReplace.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Produces different results from Spark when the search string is empty</p></li>
+</ul>
+</section>
+<section id="stringsplit">
+<h2>StringSplit<a class="headerlink" href="#stringsplit" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">StringSplit</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.StringSplit.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Regex engine differences between Java and Rust</p></li>
+</ul>
+</section>
 <section id="stringtranslate">
 <h2>StringTranslate<a class="headerlink" href="#stringtranslate" title="Link to this heading">#</a></h2>
 <p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">StringTranslate</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.StringTranslate.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
 <ul class="simple">
 <li><p>DataFusion’s translate iterates over Unicode graphemes (Spark uses code points) and substitutes U+0000 instead of treating it as a deletion sentinel</p></li>
 </ul>
+</section>
+<section id="upper">
+<h2>Upper<a class="headerlink" href="#upper" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Upper</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.caseConversion.enabled=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Results can vary depending on locale and character set</p></li>
+</ul>
 <!--END:EXPR_COMPAT-->
 </section>
 </section>
diff --git a/user-guide/latest/compatibility/expressions/spark-3.5/struct.html b/user-guide/latest/compatibility/expressions/spark-3.5/struct.html
index 53253a7a9a..e450c98880 100644
--- a/user-guide/latest/compatibility/expressions/spark-3.5/struct.html
+++ b/user-guide/latest/compatibility/expressions/spark-3.5/struct.html
@@ -582,6 +582,13 @@ under the License.
 <li><p><code class="docutils literal notranslate"><span class="pre">CreateNamedStruct</span></code> with duplicate field names is not supported</p></li>
 </ul>
 </section>
+<section id="jsontostructs">
+<h2>JsonToStructs<a class="headerlink" href="#jsontostructs" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">JsonToStructs</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.JsonToStructs.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Partially implemented and not comprehensively tested</p></li>
+</ul>
+</section>
 <section id="structstocsv">
 <h2>StructsToCsv<a class="headerlink" href="#structstocsv" title="Link to this heading">#</a></h2>
 <p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">StructsToCsv</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.StructsToCsv.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
@@ -592,6 +599,13 @@ under the License.
 <ul class="simple">
 <li><p>Complex types (arrays, maps, structs) in the schema are not supported</p></li>
 </ul>
+</section>
+<section id="structstojson">
+<h2>StructsToJson<a class="headerlink" href="#structstojson" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">StructsToJson</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.StructsToJson.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Does not support <code class="docutils literal notranslate"><span class="pre">+Infinity</span></code> and <code class="docutils literal notranslate"><span class="pre">-Infinity</span></code> for numeric types (float, double). (https://github.com/apache/datafusion-comet/issues/3016)</p></li>
+</ul>
 <!--END:EXPR_COMPAT-->
 </section>
 </section>
diff --git a/user-guide/latest/compatibility/expressions/spark-4.0/array.html b/user-guide/latest/compatibility/expressions/spark-4.0/array.html
index 0dc1d34204..5419cc2440 100644
--- a/user-guide/latest/compatibility/expressions/spark-4.0/array.html
+++ b/user-guide/latest/compatibility/expressions/spark-4.0/array.html
@@ -577,14 +577,14 @@ under the License.
 <!--BEGIN:EXPR_COMPAT[array]-->
 <section id="arrayexcept">
 <h2>ArrayExcept<a class="headerlink" href="#arrayexcept" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">ArrayExcept</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayExcept.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">ArrayExcept</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayExcept.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Null handling and ordering may differ from Spark</p></li>
 </ul>
 </section>
 <section id="arrayintersect">
 <h2>ArrayIntersect<a class="headerlink" href="#arrayintersect" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">ArrayIntersect</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayIntersect.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">ArrayIntersect</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayIntersect.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Result array element order may differ from Spark when the right array is longer than the left (DataFusion probes the longer side).</p></li>
 </ul>
@@ -595,7 +595,7 @@ under the License.
 </section>
 <section id="arrayjoin">
 <h2>ArrayJoin<a class="headerlink" href="#arrayjoin" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">ArrayJoin</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayJoin.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">ArrayJoin</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayJoin.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Null handling may differ from Spark</p></li>
 </ul>
@@ -616,7 +616,7 @@ under the License.
 </section>
 <section id="sortarray">
 <h2>SortArray<a class="headerlink" href="#sortarray" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">SortArray</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.SortArray.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">SortArray</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.SortArray.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</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>
 </ul>
diff --git a/user-guide/latest/compatibility/expressions/spark-4.0/datetime.html b/user-guide/latest/compatibility/expressions/spark-4.0/datetime.html
index e62f4a7784..62b731955c 100644
--- a/user-guide/latest/compatibility/expressions/spark-4.0/datetime.html
+++ b/user-guide/latest/compatibility/expressions/spark-4.0/datetime.html
@@ -600,7 +600,7 @@ with Spark. For dates beyond this range, functions that involve timezone-aware c
 </section>
 <section id="converttimezone">
 <h2>ConvertTimezone<a class="headerlink" href="#converttimezone" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">ConvertTimezone</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ConvertTimezone.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">ConvertTimezone</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ConvertTimezone.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Comet’s native timezone parser only accepts IANA zone IDs (e.g. <code class="docutils literal notranslate"><span class="pre">America/Los_Angeles</span></code>) and fixed offsets in <code class="docutils literal notranslate"><span class="pre">+HH:MM</span></code> form. Spark also accepts forms such as <code class="docutils literal notranslate"><span class="pre">GMT+1</span></code>, <code class="docutils literal notranslate"><span class="pre">UTC+1</span></code>, or three-letter abb [...]
 </ul>
@@ -611,6 +611,10 @@ with Spark. For dates beyond this range, functions that involve timezone-aware c
 <ul class="simple">
 <li><p>Format strings in a curated allow-list run natively via DataFusion’s <code class="docutils literal notranslate"><span class="pre">to_char</span></code> for UTC sessions. Other format strings (including non-literal formats), as well as non-UTC sessions, route through Spark’s own <code class="docutils literal notranslate"><span class="pre">DateFormatClass.doGenCode</span></code> via the Arrow-direct codegen dispatcher when <code class="docutils literal notranslate"><span class="pre" [...]
 </ul>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">DateFormatClass</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.DateFormatClass.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Non-UTC timezones may produce different results than Spark</p></li>
+</ul>
 </section>
 <section id="days">
 <h2>Days<a class="headerlink" href="#days" title="Link to this heading">#</a></h2>
@@ -621,21 +625,21 @@ with Spark. For dates beyond this range, functions that involve timezone-aware c
 </section>
 <section id="fromutctimestamp">
 <h2>FromUTCTimestamp<a class="headerlink" href="#fromutctimestamp" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">FromUTCTimestamp</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.FromUTCTimestamp.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">FromUTCTimestamp</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.FromUTCTimestamp.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Comet’s native timezone parser only accepts IANA zone IDs (e.g. <code class="docutils literal notranslate"><span class="pre">America/Los_Angeles</span></code>) and fixed offsets in <code class="docutils literal notranslate"><span class="pre">+HH:MM</span></code> form. Spark also accepts forms such as <code class="docutils literal notranslate"><span class="pre">GMT+1</span></code>, <code class="docutils literal notranslate"><span class="pre">UTC+1</span></code>, or three-letter abb [...]
 </ul>
 </section>
 <section id="fromunixtime">
 <h2>FromUnixTime<a class="headerlink" href="#fromunixtime" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">FromUnixTime</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.FromUnixTime.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">FromUnixTime</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.FromUnixTime.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Only supports the default datetime format pattern <code class="docutils literal notranslate"><span class="pre">yyyy-MM-dd</span> <span class="pre">HH:mm:ss</span></code>. DataFusion’s valid timestamp range differs from Spark (https://github.com/apache/datafusion/issues/16594)</p></li>
 </ul>
 </section>
 <section id="hour">
 <h2>Hour<a class="headerlink" href="#hour" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">Hour</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Hour.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Hour</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Hour.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Incorrectly applies timezone conversion to TimestampNTZ inputs (https://github.com/apache/datafusion-comet/issues/3180)</p></li>
 </ul>
@@ -649,14 +653,14 @@ with Spark. For dates beyond this range, functions that involve timezone-aware c
 </section>
 <section id="minute">
 <h2>Minute<a class="headerlink" href="#minute" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">Minute</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Minute.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Minute</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Minute.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Incorrectly applies timezone conversion to TimestampNTZ inputs (https://github.com/apache/datafusion-comet/issues/3180)</p></li>
 </ul>
 </section>
 <section id="second">
 <h2>Second<a class="headerlink" href="#second" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">Second</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Second.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Second</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Second.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Incorrectly applies timezone conversion to TimestampNTZ inputs (https://github.com/apache/datafusion-comet/issues/3180)</p></li>
 </ul>
@@ -670,14 +674,14 @@ with Spark. For dates beyond this range, functions that involve timezone-aware c
 </section>
 <section id="toutctimestamp">
 <h2>ToUTCTimestamp<a class="headerlink" href="#toutctimestamp" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">ToUTCTimestamp</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ToUTCTimestamp.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">ToUTCTimestamp</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ToUTCTimestamp.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Comet’s native timezone parser only accepts IANA zone IDs (e.g. <code class="docutils literal notranslate"><span class="pre">America/Los_Angeles</span></code>) and fixed offsets in <code class="docutils literal notranslate"><span class="pre">+HH:MM</span></code> form. Spark also accepts forms such as <code class="docutils literal notranslate"><span class="pre">GMT+1</span></code>, <code class="docutils literal notranslate"><span class="pre">UTC+1</span></code>, or three-letter abb [...]
 </ul>
 </section>
 <section id="truncdate">
 <h2>TruncDate<a class="headerlink" href="#truncdate" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">TruncDate</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.TruncDate.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">TruncDate</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.TruncDate.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Non-literal format strings will throw an exception instead of returning NULL</p></li>
 </ul>
@@ -688,7 +692,7 @@ with Spark. For dates beyond this range, functions that involve timezone-aware c
 </section>
 <section id="trunctimestamp">
 <h2>TruncTimestamp<a class="headerlink" href="#trunctimestamp" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">TruncTimestamp</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.TruncTimestamp.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">TruncTimestamp</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.TruncTimestamp.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Produces incorrect results when used with non-UTC timezones. Compatible when timezone is UTC. (https://github.com/apache/datafusion-comet/issues/2649)</p></li>
 <li><p>Non-literal format strings will throw an exception instead of returning NULL</p></li>
diff --git a/user-guide/latest/compatibility/expressions/spark-4.0/map.html b/user-guide/latest/compatibility/expressions/spark-4.0/map.html
index 44072fc43a..15f85f3dfb 100644
--- a/user-guide/latest/compatibility/expressions/spark-4.0/map.html
+++ b/user-guide/latest/compatibility/expressions/spark-4.0/map.html
@@ -587,7 +587,7 @@ IEEE total ordering for floating-point, which differs from Spark’s <code class
 </section>
 <section id="mapfromentries">
 <h2>MapFromEntries<a class="headerlink" href="#mapfromentries" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">MapFromEntries</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.MapFromEntries.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">MapFromEntries</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.MapFromEntries.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p><code class="docutils literal notranslate"><span class="pre">BinaryType</span></code> is not supported as a map key in <code class="docutils literal notranslate"><span class="pre">map_from_entries</span></code></p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">BinaryType</span></code> is not supported as a map value in <code class="docutils literal notranslate"><span class="pre">map_from_entries</span></code></p></li>
diff --git a/user-guide/latest/compatibility/expressions/spark-4.0/string.html b/user-guide/latest/compatibility/expressions/spark-4.0/string.html
index f7dc2fafae..683a575040 100644
--- a/user-guide/latest/compatibility/expressions/spark-4.0/string.html
+++ b/user-guide/latest/compatibility/expressions/spark-4.0/string.html
@@ -584,7 +584,7 @@ under the License.
 </section>
 <section id="concat">
 <h2>Concat<a class="headerlink" href="#concat" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">Concat</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Concat.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Concat</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Concat.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>concat does not support non-UTF8_BINARY collations (https://github.com/apache/datafusion-comet/issues/2190)</p></li>
 </ul>
@@ -593,6 +593,20 @@ under the License.
 <li><p>CONCAT supports only string input parameters</p></li>
 </ul>
 </section>
+<section id="getjsonobject">
+<h2>GetJsonObject<a class="headerlink" href="#getjsonobject" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">GetJsonObject</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.GetJsonObject.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Spark allows single-quoted JSON and unescaped control characters which Comet does not support</p></li>
+</ul>
+</section>
+<section id="initcap">
+<h2>InitCap<a class="headerlink" href="#initcap" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">InitCap</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.InitCap.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Treats hyphen as a word separator (e.g. <code class="docutils literal notranslate"><span class="pre">robert</span> <span class="pre">rose-smith</span></code> produces <code class="docutils literal notranslate"><span class="pre">Robert</span> <span class="pre">Rose-Smith</span></code> instead of Spark’s <code class="docutils literal notranslate"><span class="pre">Robert</span> <span class="pre">Rose-smith</span></code>) (https://github.com/apache/datafusion-comet/issues/1052)</p></li>
+</ul>
+</section>
 <section id="left">
 <h2>Left<a class="headerlink" href="#left" title="Link to this heading">#</a></h2>
 <p>The following cases are not supported by Comet:</p>
@@ -608,6 +622,13 @@ under the License.
 <li><p><code class="docutils literal notranslate"><span class="pre">BinaryType</span></code> input is not supported</p></li>
 </ul>
 </section>
+<section id="lower">
+<h2>Lower<a class="headerlink" href="#lower" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Lower</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.caseConversion.enabled=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Results can vary depending on locale and character set</p></li>
+</ul>
+</section>
 <section id="octetlength">
 <h2>OctetLength<a class="headerlink" href="#octetlength" title="Link to this heading">#</a></h2>
 <p>The following cases are not supported by Comet:</p>
@@ -615,9 +636,23 @@ under the License.
 <li><p><code class="docutils literal notranslate"><span class="pre">BinaryType</span></code> input is not supported</p></li>
 </ul>
 </section>
+<section id="rlike">
+<h2>RLike<a class="headerlink" href="#rlike" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">RLike</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RLike.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Uses Rust regexp engine, which has different behavior to Java regexp engine</p></li>
+</ul>
+</section>
+<section id="regexpreplace">
+<h2>RegExpReplace<a class="headerlink" href="#regexpreplace" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">RegExpReplace</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegExpReplace.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Regexp pattern may not be compatible with Spark</p></li>
+</ul>
+</section>
 <section id="reverse">
 <h2>Reverse<a class="headerlink" href="#reverse" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">Reverse</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Reverse.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Reverse</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Reverse.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>reverse on array containing binary is not supported</p></li>
 <li><p>reverse does not support non-UTF8_BINARY collations (https://github.com/apache/datafusion-comet/issues/2190)</p></li>
@@ -653,12 +688,33 @@ under the License.
 <li><p>A negative argument for the number of times to repeat throws an exception instead of returning an empty string as Spark does</p></li>
 </ul>
 </section>
+<section id="stringreplace">
+<h2>StringReplace<a class="headerlink" href="#stringreplace" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">StringReplace</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.StringReplace.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Produces different results from Spark when the search string is empty</p></li>
+</ul>
+</section>
+<section id="stringsplit">
+<h2>StringSplit<a class="headerlink" href="#stringsplit" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">StringSplit</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.StringSplit.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Regex engine differences between Java and Rust</p></li>
+</ul>
+</section>
 <section id="stringtranslate">
 <h2>StringTranslate<a class="headerlink" href="#stringtranslate" title="Link to this heading">#</a></h2>
 <p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">StringTranslate</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.StringTranslate.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
 <ul class="simple">
 <li><p>DataFusion’s translate iterates over Unicode graphemes (Spark uses code points) and substitutes U+0000 instead of treating it as a deletion sentinel</p></li>
 </ul>
+</section>
+<section id="upper">
+<h2>Upper<a class="headerlink" href="#upper" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Upper</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.caseConversion.enabled=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Results can vary depending on locale and character set</p></li>
+</ul>
 <!--END:EXPR_COMPAT-->
 </section>
 </section>
diff --git a/user-guide/latest/compatibility/expressions/spark-4.0/struct.html b/user-guide/latest/compatibility/expressions/spark-4.0/struct.html
index c5b459f683..ee4da08580 100644
--- a/user-guide/latest/compatibility/expressions/spark-4.0/struct.html
+++ b/user-guide/latest/compatibility/expressions/spark-4.0/struct.html
@@ -582,6 +582,13 @@ under the License.
 <li><p><code class="docutils literal notranslate"><span class="pre">CreateNamedStruct</span></code> with duplicate field names is not supported</p></li>
 </ul>
 </section>
+<section id="jsontostructs">
+<h2>JsonToStructs<a class="headerlink" href="#jsontostructs" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">JsonToStructs</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.JsonToStructs.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Partially implemented and not comprehensively tested</p></li>
+</ul>
+</section>
 <section id="structstocsv">
 <h2>StructsToCsv<a class="headerlink" href="#structstocsv" title="Link to this heading">#</a></h2>
 <p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">StructsToCsv</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.StructsToCsv.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
@@ -592,6 +599,13 @@ under the License.
 <ul class="simple">
 <li><p>Complex types (arrays, maps, structs) in the schema are not supported</p></li>
 </ul>
+</section>
+<section id="structstojson">
+<h2>StructsToJson<a class="headerlink" href="#structstojson" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">StructsToJson</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.StructsToJson.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Does not support <code class="docutils literal notranslate"><span class="pre">+Infinity</span></code> and <code class="docutils literal notranslate"><span class="pre">-Infinity</span></code> for numeric types (float, double). (https://github.com/apache/datafusion-comet/issues/3016)</p></li>
+</ul>
 <!--END:EXPR_COMPAT-->
 </section>
 </section>
diff --git a/user-guide/latest/compatibility/expressions/spark-4.1/array.html b/user-guide/latest/compatibility/expressions/spark-4.1/array.html
index 27a0aa047c..deadaafee7 100644
--- a/user-guide/latest/compatibility/expressions/spark-4.1/array.html
+++ b/user-guide/latest/compatibility/expressions/spark-4.1/array.html
@@ -577,14 +577,14 @@ under the License.
 <!--BEGIN:EXPR_COMPAT[array]-->
 <section id="arrayexcept">
 <h2>ArrayExcept<a class="headerlink" href="#arrayexcept" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">ArrayExcept</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayExcept.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">ArrayExcept</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayExcept.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Null handling and ordering may differ from Spark</p></li>
 </ul>
 </section>
 <section id="arrayintersect">
 <h2>ArrayIntersect<a class="headerlink" href="#arrayintersect" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">ArrayIntersect</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayIntersect.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">ArrayIntersect</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayIntersect.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Result array element order may differ from Spark when the right array is longer than the left (DataFusion probes the longer side).</p></li>
 </ul>
@@ -595,7 +595,7 @@ under the License.
 </section>
 <section id="arrayjoin">
 <h2>ArrayJoin<a class="headerlink" href="#arrayjoin" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">ArrayJoin</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayJoin.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">ArrayJoin</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ArrayJoin.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Null handling may differ from Spark</p></li>
 </ul>
@@ -616,7 +616,7 @@ under the License.
 </section>
 <section id="sortarray">
 <h2>SortArray<a class="headerlink" href="#sortarray" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">SortArray</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.SortArray.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">SortArray</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.SortArray.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</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>
 </ul>
diff --git a/user-guide/latest/compatibility/expressions/spark-4.1/datetime.html b/user-guide/latest/compatibility/expressions/spark-4.1/datetime.html
index 326217772f..c6fca3887b 100644
--- a/user-guide/latest/compatibility/expressions/spark-4.1/datetime.html
+++ b/user-guide/latest/compatibility/expressions/spark-4.1/datetime.html
@@ -600,7 +600,7 @@ with Spark. For dates beyond this range, functions that involve timezone-aware c
 </section>
 <section id="converttimezone">
 <h2>ConvertTimezone<a class="headerlink" href="#converttimezone" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">ConvertTimezone</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ConvertTimezone.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">ConvertTimezone</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ConvertTimezone.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Comet’s native timezone parser only accepts IANA zone IDs (e.g. <code class="docutils literal notranslate"><span class="pre">America/Los_Angeles</span></code>) and fixed offsets in <code class="docutils literal notranslate"><span class="pre">+HH:MM</span></code> form. Spark also accepts forms such as <code class="docutils literal notranslate"><span class="pre">GMT+1</span></code>, <code class="docutils literal notranslate"><span class="pre">UTC+1</span></code>, or three-letter abb [...]
 </ul>
@@ -611,6 +611,10 @@ with Spark. For dates beyond this range, functions that involve timezone-aware c
 <ul class="simple">
 <li><p>Format strings in a curated allow-list run natively via DataFusion’s <code class="docutils literal notranslate"><span class="pre">to_char</span></code> for UTC sessions. Other format strings (including non-literal formats), as well as non-UTC sessions, route through Spark’s own <code class="docutils literal notranslate"><span class="pre">DateFormatClass.doGenCode</span></code> via the Arrow-direct codegen dispatcher when <code class="docutils literal notranslate"><span class="pre" [...]
 </ul>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">DateFormatClass</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.DateFormatClass.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Non-UTC timezones may produce different results than Spark</p></li>
+</ul>
 </section>
 <section id="days">
 <h2>Days<a class="headerlink" href="#days" title="Link to this heading">#</a></h2>
@@ -621,21 +625,21 @@ with Spark. For dates beyond this range, functions that involve timezone-aware c
 </section>
 <section id="fromutctimestamp">
 <h2>FromUTCTimestamp<a class="headerlink" href="#fromutctimestamp" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">FromUTCTimestamp</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.FromUTCTimestamp.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">FromUTCTimestamp</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.FromUTCTimestamp.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Comet’s native timezone parser only accepts IANA zone IDs (e.g. <code class="docutils literal notranslate"><span class="pre">America/Los_Angeles</span></code>) and fixed offsets in <code class="docutils literal notranslate"><span class="pre">+HH:MM</span></code> form. Spark also accepts forms such as <code class="docutils literal notranslate"><span class="pre">GMT+1</span></code>, <code class="docutils literal notranslate"><span class="pre">UTC+1</span></code>, or three-letter abb [...]
 </ul>
 </section>
 <section id="fromunixtime">
 <h2>FromUnixTime<a class="headerlink" href="#fromunixtime" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">FromUnixTime</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.FromUnixTime.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">FromUnixTime</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.FromUnixTime.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Only supports the default datetime format pattern <code class="docutils literal notranslate"><span class="pre">yyyy-MM-dd</span> <span class="pre">HH:mm:ss</span></code>. DataFusion’s valid timestamp range differs from Spark (https://github.com/apache/datafusion/issues/16594)</p></li>
 </ul>
 </section>
 <section id="hour">
 <h2>Hour<a class="headerlink" href="#hour" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">Hour</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Hour.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Hour</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Hour.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Incorrectly applies timezone conversion to TimestampNTZ inputs (https://github.com/apache/datafusion-comet/issues/3180)</p></li>
 </ul>
@@ -649,14 +653,14 @@ with Spark. For dates beyond this range, functions that involve timezone-aware c
 </section>
 <section id="minute">
 <h2>Minute<a class="headerlink" href="#minute" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">Minute</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Minute.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Minute</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Minute.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Incorrectly applies timezone conversion to TimestampNTZ inputs (https://github.com/apache/datafusion-comet/issues/3180)</p></li>
 </ul>
 </section>
 <section id="second">
 <h2>Second<a class="headerlink" href="#second" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">Second</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Second.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Second</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Second.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Incorrectly applies timezone conversion to TimestampNTZ inputs (https://github.com/apache/datafusion-comet/issues/3180)</p></li>
 </ul>
@@ -670,14 +674,14 @@ with Spark. For dates beyond this range, functions that involve timezone-aware c
 </section>
 <section id="toutctimestamp">
 <h2>ToUTCTimestamp<a class="headerlink" href="#toutctimestamp" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">ToUTCTimestamp</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ToUTCTimestamp.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">ToUTCTimestamp</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.ToUTCTimestamp.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Comet’s native timezone parser only accepts IANA zone IDs (e.g. <code class="docutils literal notranslate"><span class="pre">America/Los_Angeles</span></code>) and fixed offsets in <code class="docutils literal notranslate"><span class="pre">+HH:MM</span></code> form. Spark also accepts forms such as <code class="docutils literal notranslate"><span class="pre">GMT+1</span></code>, <code class="docutils literal notranslate"><span class="pre">UTC+1</span></code>, or three-letter abb [...]
 </ul>
 </section>
 <section id="truncdate">
 <h2>TruncDate<a class="headerlink" href="#truncdate" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">TruncDate</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.TruncDate.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">TruncDate</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.TruncDate.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Non-literal format strings will throw an exception instead of returning NULL</p></li>
 </ul>
@@ -688,7 +692,7 @@ with Spark. For dates beyond this range, functions that involve timezone-aware c
 </section>
 <section id="trunctimestamp">
 <h2>TruncTimestamp<a class="headerlink" href="#trunctimestamp" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">TruncTimestamp</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.TruncTimestamp.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">TruncTimestamp</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.TruncTimestamp.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>Produces incorrect results when used with non-UTC timezones. Compatible when timezone is UTC. (https://github.com/apache/datafusion-comet/issues/2649)</p></li>
 <li><p>Non-literal format strings will throw an exception instead of returning NULL</p></li>
diff --git a/user-guide/latest/compatibility/expressions/spark-4.1/map.html b/user-guide/latest/compatibility/expressions/spark-4.1/map.html
index fc47051416..4ac12e25fd 100644
--- a/user-guide/latest/compatibility/expressions/spark-4.1/map.html
+++ b/user-guide/latest/compatibility/expressions/spark-4.1/map.html
@@ -587,7 +587,7 @@ IEEE total ordering for floating-point, which differs from Spark’s <code class
 </section>
 <section id="mapfromentries">
 <h2>MapFromEntries<a class="headerlink" href="#mapfromentries" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">MapFromEntries</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.MapFromEntries.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">MapFromEntries</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.MapFromEntries.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p><code class="docutils literal notranslate"><span class="pre">BinaryType</span></code> is not supported as a map key in <code class="docutils literal notranslate"><span class="pre">map_from_entries</span></code></p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">BinaryType</span></code> is not supported as a map value in <code class="docutils literal notranslate"><span class="pre">map_from_entries</span></code></p></li>
diff --git a/user-guide/latest/compatibility/expressions/spark-4.1/string.html b/user-guide/latest/compatibility/expressions/spark-4.1/string.html
index e988c48617..4f3be8acfb 100644
--- a/user-guide/latest/compatibility/expressions/spark-4.1/string.html
+++ b/user-guide/latest/compatibility/expressions/spark-4.1/string.html
@@ -584,7 +584,7 @@ under the License.
 </section>
 <section id="concat">
 <h2>Concat<a class="headerlink" href="#concat" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">Concat</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Concat.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Concat</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Concat.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>concat does not support non-UTF8_BINARY collations (https://github.com/apache/datafusion-comet/issues/2190)</p></li>
 </ul>
@@ -593,6 +593,20 @@ under the License.
 <li><p>CONCAT supports only string input parameters</p></li>
 </ul>
 </section>
+<section id="getjsonobject">
+<h2>GetJsonObject<a class="headerlink" href="#getjsonobject" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">GetJsonObject</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.GetJsonObject.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Spark allows single-quoted JSON and unescaped control characters which Comet does not support</p></li>
+</ul>
+</section>
+<section id="initcap">
+<h2>InitCap<a class="headerlink" href="#initcap" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">InitCap</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.InitCap.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Treats hyphen as a word separator (e.g. <code class="docutils literal notranslate"><span class="pre">robert</span> <span class="pre">rose-smith</span></code> produces <code class="docutils literal notranslate"><span class="pre">Robert</span> <span class="pre">Rose-Smith</span></code> instead of Spark’s <code class="docutils literal notranslate"><span class="pre">Robert</span> <span class="pre">Rose-smith</span></code>) (https://github.com/apache/datafusion-comet/issues/1052)</p></li>
+</ul>
+</section>
 <section id="left">
 <h2>Left<a class="headerlink" href="#left" title="Link to this heading">#</a></h2>
 <p>The following cases are not supported by Comet:</p>
@@ -608,6 +622,13 @@ under the License.
 <li><p><code class="docutils literal notranslate"><span class="pre">BinaryType</span></code> input is not supported</p></li>
 </ul>
 </section>
+<section id="lower">
+<h2>Lower<a class="headerlink" href="#lower" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Lower</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.caseConversion.enabled=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Results can vary depending on locale and character set</p></li>
+</ul>
+</section>
 <section id="octetlength">
 <h2>OctetLength<a class="headerlink" href="#octetlength" title="Link to this heading">#</a></h2>
 <p>The following cases are not supported by Comet:</p>
@@ -615,9 +636,23 @@ under the License.
 <li><p><code class="docutils literal notranslate"><span class="pre">BinaryType</span></code> input is not supported</p></li>
 </ul>
 </section>
+<section id="rlike">
+<h2>RLike<a class="headerlink" href="#rlike" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">RLike</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RLike.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Uses Rust regexp engine, which has different behavior to Java regexp engine</p></li>
+</ul>
+</section>
+<section id="regexpreplace">
+<h2>RegExpReplace<a class="headerlink" href="#regexpreplace" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">RegExpReplace</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.RegExpReplace.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Regexp pattern may not be compatible with Spark</p></li>
+</ul>
+</section>
 <section id="reverse">
 <h2>Reverse<a class="headerlink" href="#reverse" title="Link to this heading">#</a></h2>
-<p>By default, Comet accelerates <code class="docutils literal notranslate"><span class="pre">Reverse</span></code> using JVM codegen dispatch, which runs Spark’s generated code inside Comet’s native pipeline and matches Spark exactly. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Reverse.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Reverse</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.Reverse.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
 <ul class="simple">
 <li><p>reverse on array containing binary is not supported</p></li>
 <li><p>reverse does not support non-UTF8_BINARY collations (https://github.com/apache/datafusion-comet/issues/2190)</p></li>
@@ -653,12 +688,33 @@ under the License.
 <li><p>A negative argument for the number of times to repeat throws an exception instead of returning an empty string as Spark does</p></li>
 </ul>
 </section>
+<section id="stringreplace">
+<h2>StringReplace<a class="headerlink" href="#stringreplace" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">StringReplace</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.StringReplace.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Produces different results from Spark when the search string is empty</p></li>
+</ul>
+</section>
+<section id="stringsplit">
+<h2>StringSplit<a class="headerlink" href="#stringsplit" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">StringSplit</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.StringSplit.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Regex engine differences between Java and Rust</p></li>
+</ul>
+</section>
 <section id="stringtranslate">
 <h2>StringTranslate<a class="headerlink" href="#stringtranslate" title="Link to this heading">#</a></h2>
 <p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">StringTranslate</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.StringTranslate.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
 <ul class="simple">
 <li><p>DataFusion’s translate iterates over Unicode graphemes (Spark uses code points) and substitutes U+0000 instead of treating it as a deletion sentinel</p></li>
 </ul>
+</section>
+<section id="upper">
+<h2>Upper<a class="headerlink" href="#upper" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">Upper</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.caseConversion.enabled=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Results can vary depending on locale and character set</p></li>
+</ul>
 <!--END:EXPR_COMPAT-->
 </section>
 </section>
diff --git a/user-guide/latest/compatibility/expressions/spark-4.1/struct.html b/user-guide/latest/compatibility/expressions/spark-4.1/struct.html
index aef0d4c718..6c238de880 100644
--- a/user-guide/latest/compatibility/expressions/spark-4.1/struct.html
+++ b/user-guide/latest/compatibility/expressions/spark-4.1/struct.html
@@ -582,6 +582,13 @@ under the License.
 <li><p><code class="docutils literal notranslate"><span class="pre">CreateNamedStruct</span></code> with duplicate field names is not supported</p></li>
 </ul>
 </section>
+<section id="jsontostructs">
+<h2>JsonToStructs<a class="headerlink" href="#jsontostructs" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">JsonToStructs</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.JsonToStructs.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Partially implemented and not comprehensively tested</p></li>
+</ul>
+</section>
 <section id="structstocsv">
 <h2>StructsToCsv<a class="headerlink" href="#structstocsv" title="Link to this heading">#</a></h2>
 <p>The following incompatibilities cause <code class="docutils literal notranslate"><span class="pre">StructsToCsv</span></code> to fall back to Spark by default. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.StructsToCsv.allowIncompatible=true</span></code> to enable Comet acceleration despite these differences.</p>
@@ -592,6 +599,13 @@ under the License.
 <ul class="simple">
 <li><p>Complex types (arrays, maps, structs) in the schema are not supported</p></li>
 </ul>
+</section>
+<section id="structstojson">
+<h2>StructsToJson<a class="headerlink" href="#structstojson" title="Link to this heading">#</a></h2>
+<p>By default, Comet runs a Spark-compatible implementation of <code class="docutils literal notranslate"><span class="pre">StructsToJson</span></code>. Set <code class="docutils literal notranslate"><span class="pre">spark.comet.expression.StructsToJson.allowIncompatible=true</span></code> to use Comet’s faster native implementation instead, which has the following differences from Spark:</p>
+<ul class="simple">
+<li><p>Does not support <code class="docutils literal notranslate"><span class="pre">+Infinity</span></code> and <code class="docutils literal notranslate"><span class="pre">-Infinity</span></code> for numeric types (float, double). (https://github.com/apache/datafusion-comet/issues/3016)</p></li>
+</ul>
 <!--END:EXPR_COMPAT-->
 </section>
 </section>
diff --git a/user-guide/latest/compatibility/index.html b/user-guide/latest/compatibility/index.html
index 41b513ad3c..6dc7877598 100644
--- a/user-guide/latest/compatibility/index.html
+++ b/user-guide/latest/compatibility/index.html
@@ -579,6 +579,18 @@ under the License.
 <li><p><strong>JSON</strong>: choosing between the native and Spark-compatible engines for JSON expressions.</p></li>
 <li><p><strong>Spark versions</strong>: version-specific known issues and limitations.</p></li>
 </ul>
+<section id="compatible-by-default-opt-in-to-native">
+<h2>Compatible by default, opt in to native<a class="headerlink" href="#compatible-by-default-opt-in-to-native" title="Link to this heading">#</a></h2>
+<p>Comet runs a Spark-compatible implementation of every supported expression by default. Some
+expressions also have a faster native implementation that can differ from Spark for certain
+inputs. These are not used unless you opt in by setting the relevant
+<code class="docutils literal notranslate"><span class="pre">spark.comet.expression.&lt;Name&gt;.allowIncompatible=true</span></code> config (a few use a dedicated config, noted
+per expression below), after which you accept the documented differences.</p>
+<p>You can discover where a native opt-in is available for a specific query in the verbose extended
+explain output. A <code class="docutils literal notranslate"><span class="pre">[COMET-INFO:</span> <span class="pre">...]</span></code> segment points at an available native path and does not mean
+the operator falls back to Spark. This is distinct from <code class="docutils literal notranslate"><span class="pre">[COMET:</span> <span class="pre">...]</span></code>, which records a reason an
+operator did fall back.</p>
+</section>
 <section id="native-and-codegen-dispatch-implementations">
 <h2>Native and codegen-dispatch implementations<a class="headerlink" href="#native-and-codegen-dispatch-implementations" title="Link to this heading">#</a></h2>
 <p>Some Spark expressions have two implementations in Comet:</p>


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datafusion.apache.org
For additional commands, e-mail: commits-help@datafusion.apache.org