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 5f17ef955d Publish built docs triggered by
92f0f33e752243c1fe5ef72dd05858d224b7984c
5f17ef955d is described below
commit 5f17ef955d9d53c08ae0d9c6f27f1c2d16c0459d
Author: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
AuthorDate: Fri Jul 17 21:50:25 2026 +0000
Publish built docs triggered by 92f0f33e752243c1fe5ef72dd05858d224b7984c
---
.../compatibility/expressions/spark-3.4/map.md.txt | 2 +-
.../expressions/spark-3.4/string.md.txt | 25 ++++++++++++++++
.../compatibility/expressions/spark-3.5/map.md.txt | 2 +-
.../expressions/spark-3.5/string.md.txt | 25 ++++++++++++++++
.../compatibility/expressions/spark-4.0/map.md.txt | 2 +-
.../expressions/spark-4.0/string.md.txt | 25 ++++++++++++++++
.../compatibility/expressions/spark-4.1/map.md.txt | 2 +-
.../expressions/spark-4.1/string.md.txt | 25 ++++++++++++++++
searchindex.js | 2 +-
.../compatibility/expressions/spark-3.4/map.html | 2 +-
.../expressions/spark-3.4/string.html | 33 ++++++++++++++++++++++
.../compatibility/expressions/spark-3.5/map.html | 2 +-
.../expressions/spark-3.5/string.html | 33 ++++++++++++++++++++++
.../compatibility/expressions/spark-4.0/map.html | 2 +-
.../expressions/spark-4.0/string.html | 33 ++++++++++++++++++++++
.../compatibility/expressions/spark-4.1/map.html | 2 +-
.../expressions/spark-4.1/string.html | 33 ++++++++++++++++++++++
17 files changed, 241 insertions(+), 9 deletions(-)
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 b33cef549f..59c923b8ed 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
@@ -48,7 +48,7 @@ By default, `MapFromEntries` is evaluated in the JVM using
Spark's own code-gene
## StringToMap
-The following incompatibilities cause `StringToMap` to fall back to Spark by
default. Set `spark.comet.expression.StringToMap.allowIncompatible=true` to
enable Comet acceleration despite these differences.
+By default, `StringToMap` is evaluated in the JVM using Spark's own
code-generated implementation (run inside the Comet pipeline), which matches
Spark exactly. Set `spark.comet.expression.StringToMap.allowIncompatible=true`
to opt into Comet's native implementation instead, which has the following
differences from Spark:
- `spark.sql.legacy.truncateForEmptyRegexSplit` is enabled, so trailing empty
split entries may differ from Spark.
- `str_to_map` does not support non-UTF8_BINARY collations on the input string
or delimiters.
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 c65e76b595..cd97a75024 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
@@ -37,6 +37,18 @@ The following cases have no native implementation and always
run in the JVM usin
- CONCAT supports only string input parameters
+## Contains
+
+The following cases have no native implementation and always run in the JVM
using Spark's code-generated implementation (inside the Comet pipeline):
+
+- Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark's own `doGenCode`) because native comparison is byte-wise.
+
+## EndsWith
+
+The following cases have no native implementation and always run in the JVM
using Spark's code-generated implementation (inside the Comet pipeline):
+
+- Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark's own `doGenCode`) because native comparison is byte-wise.
+
## GetJsonObject
By default, `GetJsonObject` is evaluated in the JVM using Spark's own
code-generated implementation (run inside the Comet pipeline), which matches
Spark exactly. Set
`spark.comet.expression.GetJsonObject.allowIncompatible=true` to opt into
Comet's native implementation instead, which has the following differences from
Spark:
@@ -55,6 +67,13 @@ The following cases are not supported by Comet and always
fall back to Spark, re
- `BinaryType` input is not supported
+## Like
+
+The following cases have no native implementation and always run in the JVM
using Spark's code-generated implementation (inside the Comet pipeline):
+
+- LIKE with a custom escape character (only `\` is supported natively)
+- Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark's own `doGenCode`) because native comparison is byte-wise.
+
## Lower
By default, `Lower` is evaluated in the JVM using Spark's own code-generated
implementation (run inside the Comet pipeline), which matches Spark exactly.
Set `spark.comet.caseConversion.enabled=true` to opt into Comet's native
implementation instead, which has the following differences from Spark:
@@ -86,6 +105,12 @@ By default, `Reverse` is evaluated in the JVM using Spark's
own code-generated i
- native reverse does not support arrays whose element type contains binary,
struct, or map
- reverse does not support non-UTF8_BINARY collations
(https://github.com/apache/datafusion-comet/issues/2190)
+## StartsWith
+
+The following cases have no native implementation and always run in the JVM
using Spark's code-generated implementation (inside the Comet pipeline):
+
+- Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark's own `doGenCode`) because native comparison is byte-wise.
+
## StringLPad
The following cases are not supported by Comet and always fall back to Spark,
regardless of any `allowIncompatible` setting:
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 b33cef549f..59c923b8ed 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
@@ -48,7 +48,7 @@ By default, `MapFromEntries` is evaluated in the JVM using
Spark's own code-gene
## StringToMap
-The following incompatibilities cause `StringToMap` to fall back to Spark by
default. Set `spark.comet.expression.StringToMap.allowIncompatible=true` to
enable Comet acceleration despite these differences.
+By default, `StringToMap` is evaluated in the JVM using Spark's own
code-generated implementation (run inside the Comet pipeline), which matches
Spark exactly. Set `spark.comet.expression.StringToMap.allowIncompatible=true`
to opt into Comet's native implementation instead, which has the following
differences from Spark:
- `spark.sql.legacy.truncateForEmptyRegexSplit` is enabled, so trailing empty
split entries may differ from Spark.
- `str_to_map` does not support non-UTF8_BINARY collations on the input string
or delimiters.
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 c65e76b595..cd97a75024 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
@@ -37,6 +37,18 @@ The following cases have no native implementation and always
run in the JVM usin
- CONCAT supports only string input parameters
+## Contains
+
+The following cases have no native implementation and always run in the JVM
using Spark's code-generated implementation (inside the Comet pipeline):
+
+- Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark's own `doGenCode`) because native comparison is byte-wise.
+
+## EndsWith
+
+The following cases have no native implementation and always run in the JVM
using Spark's code-generated implementation (inside the Comet pipeline):
+
+- Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark's own `doGenCode`) because native comparison is byte-wise.
+
## GetJsonObject
By default, `GetJsonObject` is evaluated in the JVM using Spark's own
code-generated implementation (run inside the Comet pipeline), which matches
Spark exactly. Set
`spark.comet.expression.GetJsonObject.allowIncompatible=true` to opt into
Comet's native implementation instead, which has the following differences from
Spark:
@@ -55,6 +67,13 @@ The following cases are not supported by Comet and always
fall back to Spark, re
- `BinaryType` input is not supported
+## Like
+
+The following cases have no native implementation and always run in the JVM
using Spark's code-generated implementation (inside the Comet pipeline):
+
+- LIKE with a custom escape character (only `\` is supported natively)
+- Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark's own `doGenCode`) because native comparison is byte-wise.
+
## Lower
By default, `Lower` is evaluated in the JVM using Spark's own code-generated
implementation (run inside the Comet pipeline), which matches Spark exactly.
Set `spark.comet.caseConversion.enabled=true` to opt into Comet's native
implementation instead, which has the following differences from Spark:
@@ -86,6 +105,12 @@ By default, `Reverse` is evaluated in the JVM using Spark's
own code-generated i
- native reverse does not support arrays whose element type contains binary,
struct, or map
- reverse does not support non-UTF8_BINARY collations
(https://github.com/apache/datafusion-comet/issues/2190)
+## StartsWith
+
+The following cases have no native implementation and always run in the JVM
using Spark's code-generated implementation (inside the Comet pipeline):
+
+- Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark's own `doGenCode`) because native comparison is byte-wise.
+
## StringLPad
The following cases are not supported by Comet and always fall back to Spark,
regardless of any `allowIncompatible` setting:
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 adce8ddaf4..e5c0f79d10 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
@@ -58,7 +58,7 @@ The following cases are not supported by Comet and always
fall back to Spark, re
## StringToMap
-The following incompatibilities cause `StringToMap` to fall back to Spark by
default. Set `spark.comet.expression.StringToMap.allowIncompatible=true` to
enable Comet acceleration despite these differences.
+By default, `StringToMap` is evaluated in the JVM using Spark's own
code-generated implementation (run inside the Comet pipeline), which matches
Spark exactly. Set `spark.comet.expression.StringToMap.allowIncompatible=true`
to opt into Comet's native implementation instead, which has the following
differences from Spark:
- `spark.sql.legacy.truncateForEmptyRegexSplit` is enabled, so trailing empty
split entries may differ from Spark.
- `str_to_map` does not support non-UTF8_BINARY collations on the input string
or delimiters.
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 c65e76b595..cd97a75024 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
@@ -37,6 +37,18 @@ The following cases have no native implementation and always
run in the JVM usin
- CONCAT supports only string input parameters
+## Contains
+
+The following cases have no native implementation and always run in the JVM
using Spark's code-generated implementation (inside the Comet pipeline):
+
+- Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark's own `doGenCode`) because native comparison is byte-wise.
+
+## EndsWith
+
+The following cases have no native implementation and always run in the JVM
using Spark's code-generated implementation (inside the Comet pipeline):
+
+- Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark's own `doGenCode`) because native comparison is byte-wise.
+
## GetJsonObject
By default, `GetJsonObject` is evaluated in the JVM using Spark's own
code-generated implementation (run inside the Comet pipeline), which matches
Spark exactly. Set
`spark.comet.expression.GetJsonObject.allowIncompatible=true` to opt into
Comet's native implementation instead, which has the following differences from
Spark:
@@ -55,6 +67,13 @@ The following cases are not supported by Comet and always
fall back to Spark, re
- `BinaryType` input is not supported
+## Like
+
+The following cases have no native implementation and always run in the JVM
using Spark's code-generated implementation (inside the Comet pipeline):
+
+- LIKE with a custom escape character (only `\` is supported natively)
+- Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark's own `doGenCode`) because native comparison is byte-wise.
+
## Lower
By default, `Lower` is evaluated in the JVM using Spark's own code-generated
implementation (run inside the Comet pipeline), which matches Spark exactly.
Set `spark.comet.caseConversion.enabled=true` to opt into Comet's native
implementation instead, which has the following differences from Spark:
@@ -86,6 +105,12 @@ By default, `Reverse` is evaluated in the JVM using Spark's
own code-generated i
- native reverse does not support arrays whose element type contains binary,
struct, or map
- reverse does not support non-UTF8_BINARY collations
(https://github.com/apache/datafusion-comet/issues/2190)
+## StartsWith
+
+The following cases have no native implementation and always run in the JVM
using Spark's code-generated implementation (inside the Comet pipeline):
+
+- Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark's own `doGenCode`) because native comparison is byte-wise.
+
## StringLPad
The following cases are not supported by Comet and always fall back to Spark,
regardless of any `allowIncompatible` setting:
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 adce8ddaf4..e5c0f79d10 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
@@ -58,7 +58,7 @@ The following cases are not supported by Comet and always
fall back to Spark, re
## StringToMap
-The following incompatibilities cause `StringToMap` to fall back to Spark by
default. Set `spark.comet.expression.StringToMap.allowIncompatible=true` to
enable Comet acceleration despite these differences.
+By default, `StringToMap` is evaluated in the JVM using Spark's own
code-generated implementation (run inside the Comet pipeline), which matches
Spark exactly. Set `spark.comet.expression.StringToMap.allowIncompatible=true`
to opt into Comet's native implementation instead, which has the following
differences from Spark:
- `spark.sql.legacy.truncateForEmptyRegexSplit` is enabled, so trailing empty
split entries may differ from Spark.
- `str_to_map` does not support non-UTF8_BINARY collations on the input string
or delimiters.
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 c65e76b595..cd97a75024 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
@@ -37,6 +37,18 @@ The following cases have no native implementation and always
run in the JVM usin
- CONCAT supports only string input parameters
+## Contains
+
+The following cases have no native implementation and always run in the JVM
using Spark's code-generated implementation (inside the Comet pipeline):
+
+- Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark's own `doGenCode`) because native comparison is byte-wise.
+
+## EndsWith
+
+The following cases have no native implementation and always run in the JVM
using Spark's code-generated implementation (inside the Comet pipeline):
+
+- Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark's own `doGenCode`) because native comparison is byte-wise.
+
## GetJsonObject
By default, `GetJsonObject` is evaluated in the JVM using Spark's own
code-generated implementation (run inside the Comet pipeline), which matches
Spark exactly. Set
`spark.comet.expression.GetJsonObject.allowIncompatible=true` to opt into
Comet's native implementation instead, which has the following differences from
Spark:
@@ -55,6 +67,13 @@ The following cases are not supported by Comet and always
fall back to Spark, re
- `BinaryType` input is not supported
+## Like
+
+The following cases have no native implementation and always run in the JVM
using Spark's code-generated implementation (inside the Comet pipeline):
+
+- LIKE with a custom escape character (only `\` is supported natively)
+- Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark's own `doGenCode`) because native comparison is byte-wise.
+
## Lower
By default, `Lower` is evaluated in the JVM using Spark's own code-generated
implementation (run inside the Comet pipeline), which matches Spark exactly.
Set `spark.comet.caseConversion.enabled=true` to opt into Comet's native
implementation instead, which has the following differences from Spark:
@@ -86,6 +105,12 @@ By default, `Reverse` is evaluated in the JVM using Spark's
own code-generated i
- native reverse does not support arrays whose element type contains binary,
struct, or map
- reverse does not support non-UTF8_BINARY collations
(https://github.com/apache/datafusion-comet/issues/2190)
+## StartsWith
+
+The following cases have no native implementation and always run in the JVM
using Spark's code-generated implementation (inside the Comet pipeline):
+
+- Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark's own `doGenCode`) because native comparison is byte-wise.
+
## StringLPad
The following cases are not supported by Comet and always fall back to Spark,
regardless of any `allowIncompatible` setting:
diff --git a/searchindex.js b/searchindex.js
index 0d153e2d3e..c04f3f60e9 100644
--- a/searchindex.js
+++ b/searchindex.js
@@ -1 +1 @@
-Search.setIndex({"alltitles": {"!": [[52, "id1"]], "%": [[50, "id1"]], "&":
[[40, "id1"]], "*": [[50, "id2"]], "+": [[50, "id3"]], "-": [[50, "id4"]], "/":
[[50, "id5"]], "1. Format Your Code": [[37, "format-your-code"]], "1. Install
Comet": [[58, "install-comet"], [68, "install-comet"]], "1. Native Operators
(nativeExecs map)": [[26, "native-operators-nativeexecs-map"]], "2. Build and
Verify": [[37, "build-and-verify"]], "2. Clone Iceberg and Apply Diff": [[58,
"clone-iceberg-and-apply- [...]
\ No newline at end of file
+Search.setIndex({"alltitles": {"!": [[52, "id1"]], "%": [[50, "id1"]], "&":
[[40, "id1"]], "*": [[50, "id2"]], "+": [[50, "id3"]], "-": [[50, "id4"]], "/":
[[50, "id5"]], "1. Format Your Code": [[37, "format-your-code"]], "1. Install
Comet": [[58, "install-comet"], [68, "install-comet"]], "1. Native Operators
(nativeExecs map)": [[26, "native-operators-nativeexecs-map"]], "2. Build and
Verify": [[37, "build-and-verify"]], "2. Clone Iceberg and Apply Diff": [[58,
"clone-iceberg-and-apply- [...]
\ No newline at end of file
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 97224e09ab..99b73a5e1e 100644
--- a/user-guide/latest/compatibility/expressions/spark-3.4/map.html
+++ b/user-guide/latest/compatibility/expressions/spark-3.4/map.html
@@ -776,7 +776,7 @@ IEEE total ordering for floating-point, which differs from
Spark’s <code class
</section>
<section id="stringtomap">
<h2>StringToMap<a class="headerlink" href="#stringtomap" title="Link to this
heading">#</a></h2>
-<p>The following incompatibilities cause <code class="docutils literal
notranslate"><span class="pre">StringToMap</span></code> to fall back to Spark
by default. Set <code class="docutils literal notranslate"><span
class="pre">spark.comet.expression.StringToMap.allowIncompatible=true</span></code>
to enable Comet acceleration despite these differences.</p>
+<p>By default, <code class="docutils literal notranslate"><span
class="pre">StringToMap</span></code> is evaluated in the JVM using Spark’s own
code-generated implementation (run inside the Comet pipeline), which matches
Spark exactly. Set <code class="docutils literal notranslate"><span
class="pre">spark.comet.expression.StringToMap.allowIncompatible=true</span></code>
to opt into Comet’s native implementation instead, which has the following
differences from Spark:</p>
<ul class="simple">
<li><p><code class="docutils literal notranslate"><span
class="pre">spark.sql.legacy.truncateForEmptyRegexSplit</span></code> is
enabled, so trailing empty split entries may differ from Spark.</p></li>
<li><p><code class="docutils literal notranslate"><span
class="pre">str_to_map</span></code> does not support non-UTF8_BINARY
collations on the input string or delimiters.</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 3e8b84e1f8..ed94297d93 100644
--- a/user-guide/latest/compatibility/expressions/spark-3.4/string.html
+++ b/user-guide/latest/compatibility/expressions/spark-3.4/string.html
@@ -766,6 +766,20 @@ under the License.
<li><p>CONCAT supports only string input parameters</p></li>
</ul>
</section>
+<section id="contains">
+<h2>Contains<a class="headerlink" href="#contains" title="Link to this
heading">#</a></h2>
+<p>The following cases have no native implementation and always run in the JVM
using Spark’s code-generated implementation (inside the Comet pipeline):</p>
+<ul class="simple">
+<li><p>Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark’s own <code class="docutils literal notranslate"><span
class="pre">doGenCode</span></code>) because native comparison is
byte-wise.</p></li>
+</ul>
+</section>
+<section id="endswith">
+<h2>EndsWith<a class="headerlink" href="#endswith" title="Link to this
heading">#</a></h2>
+<p>The following cases have no native implementation and always run in the JVM
using Spark’s code-generated implementation (inside the Comet pipeline):</p>
+<ul class="simple">
+<li><p>Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark’s own <code class="docutils literal notranslate"><span
class="pre">doGenCode</span></code>) because native comparison is
byte-wise.</p></li>
+</ul>
+</section>
<section id="getjsonobject">
<h2>GetJsonObject<a class="headerlink" href="#getjsonobject" title="Link to
this heading">#</a></h2>
<p>By default, <code class="docutils literal notranslate"><span
class="pre">GetJsonObject</span></code> is evaluated in the JVM using Spark’s
own code-generated implementation (run inside the Comet pipeline), which
matches Spark exactly. Set <code class="docutils literal notranslate"><span
class="pre">spark.comet.expression.GetJsonObject.allowIncompatible=true</span></code>
to opt into Comet’s native implementation instead, which has the following
differences from Spark:</p>
@@ -787,6 +801,14 @@ 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="like">
+<h2>Like<a class="headerlink" href="#like" title="Link to this
heading">#</a></h2>
+<p>The following cases have no native implementation and always run in the JVM
using Spark’s code-generated implementation (inside the Comet pipeline):</p>
+<ul class="simple">
+<li><p>LIKE with a custom escape character (only <code class="docutils literal
notranslate"><span class="pre">\</span></code> is supported natively)</p></li>
+<li><p>Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark’s own <code class="docutils literal notranslate"><span
class="pre">doGenCode</span></code>) because native comparison is
byte-wise.</p></li>
+</ul>
+</section>
<section id="lower">
<h2>Lower<a class="headerlink" href="#lower" title="Link to this
heading">#</a></h2>
<p>By default, <code class="docutils literal notranslate"><span
class="pre">Lower</span></code> is evaluated in the JVM using Spark’s own
code-generated implementation (run inside the Comet pipeline), which matches
Spark exactly. Set <code class="docutils literal notranslate"><span
class="pre">spark.comet.caseConversion.enabled=true</span></code> to opt into
Comet’s native implementation instead, which has the following differences from
Spark:</p>
@@ -823,6 +845,13 @@ under the License.
<li><p>reverse does not support non-UTF8_BINARY collations
(https://github.com/apache/datafusion-comet/issues/2190)</p></li>
</ul>
</section>
+<section id="startswith">
+<h2>StartsWith<a class="headerlink" href="#startswith" title="Link to this
heading">#</a></h2>
+<p>The following cases have no native implementation and always run in the JVM
using Spark’s code-generated implementation (inside the Comet pipeline):</p>
+<ul class="simple">
+<li><p>Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark’s own <code class="docutils literal notranslate"><span
class="pre">doGenCode</span></code>) because native comparison is
byte-wise.</p></li>
+</ul>
+</section>
<section id="stringlpad">
<h2>StringLPad<a class="headerlink" href="#stringlpad" title="Link to this
heading">#</a></h2>
<p>The following cases are not supported by Comet and always fall back to
Spark, regardless of any <code class="docutils literal notranslate"><span
class="pre">allowIncompatible</span></code> setting:</p>
@@ -926,14 +955,18 @@ under the License.
<ul class="visible nav section-nav flex-column">
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#bitlength">BitLength</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#concat">Concat</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#contains">Contains</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#endswith">EndsWith</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#getjsonobject">GetJsonObject</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#initcap">InitCap</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#length">Length</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#like">Like</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#lower">Lower</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#octetlength">OctetLength</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#rlike">RLike</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#regexpreplace">RegExpReplace</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#reverse">Reverse</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#startswith">StartsWith</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#stringlpad">StringLPad</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#stringrpad">StringRPad</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#stringrepeat">StringRepeat</a></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 1746c15639..018cdec929 100644
--- a/user-guide/latest/compatibility/expressions/spark-3.5/map.html
+++ b/user-guide/latest/compatibility/expressions/spark-3.5/map.html
@@ -776,7 +776,7 @@ IEEE total ordering for floating-point, which differs from
Spark’s <code class
</section>
<section id="stringtomap">
<h2>StringToMap<a class="headerlink" href="#stringtomap" title="Link to this
heading">#</a></h2>
-<p>The following incompatibilities cause <code class="docutils literal
notranslate"><span class="pre">StringToMap</span></code> to fall back to Spark
by default. Set <code class="docutils literal notranslate"><span
class="pre">spark.comet.expression.StringToMap.allowIncompatible=true</span></code>
to enable Comet acceleration despite these differences.</p>
+<p>By default, <code class="docutils literal notranslate"><span
class="pre">StringToMap</span></code> is evaluated in the JVM using Spark’s own
code-generated implementation (run inside the Comet pipeline), which matches
Spark exactly. Set <code class="docutils literal notranslate"><span
class="pre">spark.comet.expression.StringToMap.allowIncompatible=true</span></code>
to opt into Comet’s native implementation instead, which has the following
differences from Spark:</p>
<ul class="simple">
<li><p><code class="docutils literal notranslate"><span
class="pre">spark.sql.legacy.truncateForEmptyRegexSplit</span></code> is
enabled, so trailing empty split entries may differ from Spark.</p></li>
<li><p><code class="docutils literal notranslate"><span
class="pre">str_to_map</span></code> does not support non-UTF8_BINARY
collations on the input string or delimiters.</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 ceef5d91c4..b0b47290e2 100644
--- a/user-guide/latest/compatibility/expressions/spark-3.5/string.html
+++ b/user-guide/latest/compatibility/expressions/spark-3.5/string.html
@@ -766,6 +766,20 @@ under the License.
<li><p>CONCAT supports only string input parameters</p></li>
</ul>
</section>
+<section id="contains">
+<h2>Contains<a class="headerlink" href="#contains" title="Link to this
heading">#</a></h2>
+<p>The following cases have no native implementation and always run in the JVM
using Spark’s code-generated implementation (inside the Comet pipeline):</p>
+<ul class="simple">
+<li><p>Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark’s own <code class="docutils literal notranslate"><span
class="pre">doGenCode</span></code>) because native comparison is
byte-wise.</p></li>
+</ul>
+</section>
+<section id="endswith">
+<h2>EndsWith<a class="headerlink" href="#endswith" title="Link to this
heading">#</a></h2>
+<p>The following cases have no native implementation and always run in the JVM
using Spark’s code-generated implementation (inside the Comet pipeline):</p>
+<ul class="simple">
+<li><p>Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark’s own <code class="docutils literal notranslate"><span
class="pre">doGenCode</span></code>) because native comparison is
byte-wise.</p></li>
+</ul>
+</section>
<section id="getjsonobject">
<h2>GetJsonObject<a class="headerlink" href="#getjsonobject" title="Link to
this heading">#</a></h2>
<p>By default, <code class="docutils literal notranslate"><span
class="pre">GetJsonObject</span></code> is evaluated in the JVM using Spark’s
own code-generated implementation (run inside the Comet pipeline), which
matches Spark exactly. Set <code class="docutils literal notranslate"><span
class="pre">spark.comet.expression.GetJsonObject.allowIncompatible=true</span></code>
to opt into Comet’s native implementation instead, which has the following
differences from Spark:</p>
@@ -787,6 +801,14 @@ 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="like">
+<h2>Like<a class="headerlink" href="#like" title="Link to this
heading">#</a></h2>
+<p>The following cases have no native implementation and always run in the JVM
using Spark’s code-generated implementation (inside the Comet pipeline):</p>
+<ul class="simple">
+<li><p>LIKE with a custom escape character (only <code class="docutils literal
notranslate"><span class="pre">\</span></code> is supported natively)</p></li>
+<li><p>Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark’s own <code class="docutils literal notranslate"><span
class="pre">doGenCode</span></code>) because native comparison is
byte-wise.</p></li>
+</ul>
+</section>
<section id="lower">
<h2>Lower<a class="headerlink" href="#lower" title="Link to this
heading">#</a></h2>
<p>By default, <code class="docutils literal notranslate"><span
class="pre">Lower</span></code> is evaluated in the JVM using Spark’s own
code-generated implementation (run inside the Comet pipeline), which matches
Spark exactly. Set <code class="docutils literal notranslate"><span
class="pre">spark.comet.caseConversion.enabled=true</span></code> to opt into
Comet’s native implementation instead, which has the following differences from
Spark:</p>
@@ -823,6 +845,13 @@ under the License.
<li><p>reverse does not support non-UTF8_BINARY collations
(https://github.com/apache/datafusion-comet/issues/2190)</p></li>
</ul>
</section>
+<section id="startswith">
+<h2>StartsWith<a class="headerlink" href="#startswith" title="Link to this
heading">#</a></h2>
+<p>The following cases have no native implementation and always run in the JVM
using Spark’s code-generated implementation (inside the Comet pipeline):</p>
+<ul class="simple">
+<li><p>Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark’s own <code class="docutils literal notranslate"><span
class="pre">doGenCode</span></code>) because native comparison is
byte-wise.</p></li>
+</ul>
+</section>
<section id="stringlpad">
<h2>StringLPad<a class="headerlink" href="#stringlpad" title="Link to this
heading">#</a></h2>
<p>The following cases are not supported by Comet and always fall back to
Spark, regardless of any <code class="docutils literal notranslate"><span
class="pre">allowIncompatible</span></code> setting:</p>
@@ -926,14 +955,18 @@ under the License.
<ul class="visible nav section-nav flex-column">
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#bitlength">BitLength</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#concat">Concat</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#contains">Contains</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#endswith">EndsWith</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#getjsonobject">GetJsonObject</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#initcap">InitCap</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#length">Length</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#like">Like</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#lower">Lower</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#octetlength">OctetLength</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#rlike">RLike</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#regexpreplace">RegExpReplace</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#reverse">Reverse</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#startswith">StartsWith</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#stringlpad">StringLPad</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#stringrpad">StringRPad</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#stringrepeat">StringRepeat</a></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 ea79039cc4..7bb6ab4c4c 100644
--- a/user-guide/latest/compatibility/expressions/spark-4.0/map.html
+++ b/user-guide/latest/compatibility/expressions/spark-4.0/map.html
@@ -787,7 +787,7 @@ IEEE total ordering for floating-point, which differs from
Spark’s <code class
</section>
<section id="stringtomap">
<h2>StringToMap<a class="headerlink" href="#stringtomap" title="Link to this
heading">#</a></h2>
-<p>The following incompatibilities cause <code class="docutils literal
notranslate"><span class="pre">StringToMap</span></code> to fall back to Spark
by default. Set <code class="docutils literal notranslate"><span
class="pre">spark.comet.expression.StringToMap.allowIncompatible=true</span></code>
to enable Comet acceleration despite these differences.</p>
+<p>By default, <code class="docutils literal notranslate"><span
class="pre">StringToMap</span></code> is evaluated in the JVM using Spark’s own
code-generated implementation (run inside the Comet pipeline), which matches
Spark exactly. Set <code class="docutils literal notranslate"><span
class="pre">spark.comet.expression.StringToMap.allowIncompatible=true</span></code>
to opt into Comet’s native implementation instead, which has the following
differences from Spark:</p>
<ul class="simple">
<li><p><code class="docutils literal notranslate"><span
class="pre">spark.sql.legacy.truncateForEmptyRegexSplit</span></code> is
enabled, so trailing empty split entries may differ from Spark.</p></li>
<li><p><code class="docutils literal notranslate"><span
class="pre">str_to_map</span></code> does not support non-UTF8_BINARY
collations on the input string or delimiters.</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 83c378d2ad..7ba2d95dad 100644
--- a/user-guide/latest/compatibility/expressions/spark-4.0/string.html
+++ b/user-guide/latest/compatibility/expressions/spark-4.0/string.html
@@ -766,6 +766,20 @@ under the License.
<li><p>CONCAT supports only string input parameters</p></li>
</ul>
</section>
+<section id="contains">
+<h2>Contains<a class="headerlink" href="#contains" title="Link to this
heading">#</a></h2>
+<p>The following cases have no native implementation and always run in the JVM
using Spark’s code-generated implementation (inside the Comet pipeline):</p>
+<ul class="simple">
+<li><p>Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark’s own <code class="docutils literal notranslate"><span
class="pre">doGenCode</span></code>) because native comparison is
byte-wise.</p></li>
+</ul>
+</section>
+<section id="endswith">
+<h2>EndsWith<a class="headerlink" href="#endswith" title="Link to this
heading">#</a></h2>
+<p>The following cases have no native implementation and always run in the JVM
using Spark’s code-generated implementation (inside the Comet pipeline):</p>
+<ul class="simple">
+<li><p>Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark’s own <code class="docutils literal notranslate"><span
class="pre">doGenCode</span></code>) because native comparison is
byte-wise.</p></li>
+</ul>
+</section>
<section id="getjsonobject">
<h2>GetJsonObject<a class="headerlink" href="#getjsonobject" title="Link to
this heading">#</a></h2>
<p>By default, <code class="docutils literal notranslate"><span
class="pre">GetJsonObject</span></code> is evaluated in the JVM using Spark’s
own code-generated implementation (run inside the Comet pipeline), which
matches Spark exactly. Set <code class="docutils literal notranslate"><span
class="pre">spark.comet.expression.GetJsonObject.allowIncompatible=true</span></code>
to opt into Comet’s native implementation instead, which has the following
differences from Spark:</p>
@@ -787,6 +801,14 @@ 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="like">
+<h2>Like<a class="headerlink" href="#like" title="Link to this
heading">#</a></h2>
+<p>The following cases have no native implementation and always run in the JVM
using Spark’s code-generated implementation (inside the Comet pipeline):</p>
+<ul class="simple">
+<li><p>LIKE with a custom escape character (only <code class="docutils literal
notranslate"><span class="pre">\</span></code> is supported natively)</p></li>
+<li><p>Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark’s own <code class="docutils literal notranslate"><span
class="pre">doGenCode</span></code>) because native comparison is
byte-wise.</p></li>
+</ul>
+</section>
<section id="lower">
<h2>Lower<a class="headerlink" href="#lower" title="Link to this
heading">#</a></h2>
<p>By default, <code class="docutils literal notranslate"><span
class="pre">Lower</span></code> is evaluated in the JVM using Spark’s own
code-generated implementation (run inside the Comet pipeline), which matches
Spark exactly. Set <code class="docutils literal notranslate"><span
class="pre">spark.comet.caseConversion.enabled=true</span></code> to opt into
Comet’s native implementation instead, which has the following differences from
Spark:</p>
@@ -823,6 +845,13 @@ under the License.
<li><p>reverse does not support non-UTF8_BINARY collations
(https://github.com/apache/datafusion-comet/issues/2190)</p></li>
</ul>
</section>
+<section id="startswith">
+<h2>StartsWith<a class="headerlink" href="#startswith" title="Link to this
heading">#</a></h2>
+<p>The following cases have no native implementation and always run in the JVM
using Spark’s code-generated implementation (inside the Comet pipeline):</p>
+<ul class="simple">
+<li><p>Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark’s own <code class="docutils literal notranslate"><span
class="pre">doGenCode</span></code>) because native comparison is
byte-wise.</p></li>
+</ul>
+</section>
<section id="stringlpad">
<h2>StringLPad<a class="headerlink" href="#stringlpad" title="Link to this
heading">#</a></h2>
<p>The following cases are not supported by Comet and always fall back to
Spark, regardless of any <code class="docutils literal notranslate"><span
class="pre">allowIncompatible</span></code> setting:</p>
@@ -926,14 +955,18 @@ under the License.
<ul class="visible nav section-nav flex-column">
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#bitlength">BitLength</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#concat">Concat</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#contains">Contains</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#endswith">EndsWith</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#getjsonobject">GetJsonObject</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#initcap">InitCap</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#length">Length</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#like">Like</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#lower">Lower</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#octetlength">OctetLength</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#rlike">RLike</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#regexpreplace">RegExpReplace</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#reverse">Reverse</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#startswith">StartsWith</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#stringlpad">StringLPad</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#stringrpad">StringRPad</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#stringrepeat">StringRepeat</a></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 e1b17c5fb8..d3f0a56da1 100644
--- a/user-guide/latest/compatibility/expressions/spark-4.1/map.html
+++ b/user-guide/latest/compatibility/expressions/spark-4.1/map.html
@@ -787,7 +787,7 @@ IEEE total ordering for floating-point, which differs from
Spark’s <code class
</section>
<section id="stringtomap">
<h2>StringToMap<a class="headerlink" href="#stringtomap" title="Link to this
heading">#</a></h2>
-<p>The following incompatibilities cause <code class="docutils literal
notranslate"><span class="pre">StringToMap</span></code> to fall back to Spark
by default. Set <code class="docutils literal notranslate"><span
class="pre">spark.comet.expression.StringToMap.allowIncompatible=true</span></code>
to enable Comet acceleration despite these differences.</p>
+<p>By default, <code class="docutils literal notranslate"><span
class="pre">StringToMap</span></code> is evaluated in the JVM using Spark’s own
code-generated implementation (run inside the Comet pipeline), which matches
Spark exactly. Set <code class="docutils literal notranslate"><span
class="pre">spark.comet.expression.StringToMap.allowIncompatible=true</span></code>
to opt into Comet’s native implementation instead, which has the following
differences from Spark:</p>
<ul class="simple">
<li><p><code class="docutils literal notranslate"><span
class="pre">spark.sql.legacy.truncateForEmptyRegexSplit</span></code> is
enabled, so trailing empty split entries may differ from Spark.</p></li>
<li><p><code class="docutils literal notranslate"><span
class="pre">str_to_map</span></code> does not support non-UTF8_BINARY
collations on the input string or delimiters.</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 2c63bbb134..5dbc0a6ac6 100644
--- a/user-guide/latest/compatibility/expressions/spark-4.1/string.html
+++ b/user-guide/latest/compatibility/expressions/spark-4.1/string.html
@@ -766,6 +766,20 @@ under the License.
<li><p>CONCAT supports only string input parameters</p></li>
</ul>
</section>
+<section id="contains">
+<h2>Contains<a class="headerlink" href="#contains" title="Link to this
heading">#</a></h2>
+<p>The following cases have no native implementation and always run in the JVM
using Spark’s code-generated implementation (inside the Comet pipeline):</p>
+<ul class="simple">
+<li><p>Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark’s own <code class="docutils literal notranslate"><span
class="pre">doGenCode</span></code>) because native comparison is
byte-wise.</p></li>
+</ul>
+</section>
+<section id="endswith">
+<h2>EndsWith<a class="headerlink" href="#endswith" title="Link to this
heading">#</a></h2>
+<p>The following cases have no native implementation and always run in the JVM
using Spark’s code-generated implementation (inside the Comet pipeline):</p>
+<ul class="simple">
+<li><p>Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark’s own <code class="docutils literal notranslate"><span
class="pre">doGenCode</span></code>) because native comparison is
byte-wise.</p></li>
+</ul>
+</section>
<section id="getjsonobject">
<h2>GetJsonObject<a class="headerlink" href="#getjsonobject" title="Link to
this heading">#</a></h2>
<p>By default, <code class="docutils literal notranslate"><span
class="pre">GetJsonObject</span></code> is evaluated in the JVM using Spark’s
own code-generated implementation (run inside the Comet pipeline), which
matches Spark exactly. Set <code class="docutils literal notranslate"><span
class="pre">spark.comet.expression.GetJsonObject.allowIncompatible=true</span></code>
to opt into Comet’s native implementation instead, which has the following
differences from Spark:</p>
@@ -787,6 +801,14 @@ 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="like">
+<h2>Like<a class="headerlink" href="#like" title="Link to this
heading">#</a></h2>
+<p>The following cases have no native implementation and always run in the JVM
using Spark’s code-generated implementation (inside the Comet pipeline):</p>
+<ul class="simple">
+<li><p>LIKE with a custom escape character (only <code class="docutils literal
notranslate"><span class="pre">\</span></code> is supported natively)</p></li>
+<li><p>Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark’s own <code class="docutils literal notranslate"><span
class="pre">doGenCode</span></code>) because native comparison is
byte-wise.</p></li>
+</ul>
+</section>
<section id="lower">
<h2>Lower<a class="headerlink" href="#lower" title="Link to this
heading">#</a></h2>
<p>By default, <code class="docutils literal notranslate"><span
class="pre">Lower</span></code> is evaluated in the JVM using Spark’s own
code-generated implementation (run inside the Comet pipeline), which matches
Spark exactly. Set <code class="docutils literal notranslate"><span
class="pre">spark.comet.caseConversion.enabled=true</span></code> to opt into
Comet’s native implementation instead, which has the following differences from
Spark:</p>
@@ -823,6 +845,13 @@ under the License.
<li><p>reverse does not support non-UTF8_BINARY collations
(https://github.com/apache/datafusion-comet/issues/2190)</p></li>
</ul>
</section>
+<section id="startswith">
+<h2>StartsWith<a class="headerlink" href="#startswith" title="Link to this
heading">#</a></h2>
+<p>The following cases have no native implementation and always run in the JVM
using Spark’s code-generated implementation (inside the Comet pipeline):</p>
+<ul class="simple">
+<li><p>Non-UTF8_BINARY collated operands are routed through the JVM codegen
dispatcher (Spark’s own <code class="docutils literal notranslate"><span
class="pre">doGenCode</span></code>) because native comparison is
byte-wise.</p></li>
+</ul>
+</section>
<section id="stringlpad">
<h2>StringLPad<a class="headerlink" href="#stringlpad" title="Link to this
heading">#</a></h2>
<p>The following cases are not supported by Comet and always fall back to
Spark, regardless of any <code class="docutils literal notranslate"><span
class="pre">allowIncompatible</span></code> setting:</p>
@@ -926,14 +955,18 @@ under the License.
<ul class="visible nav section-nav flex-column">
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#bitlength">BitLength</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#concat">Concat</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#contains">Contains</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#endswith">EndsWith</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#getjsonobject">GetJsonObject</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#initcap">InitCap</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#length">Length</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#like">Like</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#lower">Lower</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#octetlength">OctetLength</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#rlike">RLike</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#regexpreplace">RegExpReplace</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#reverse">Reverse</a></li>
+<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#startswith">StartsWith</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#stringlpad">StringLPad</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#stringrpad">StringRPad</a></li>
<li class="toc-h2 nav-item toc-entry"><a class="reference internal nav-link"
href="#stringrepeat">StringRepeat</a></li>
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
