[parthchandra]

Auto-insert CometSparkToColumnarExec at an unsupported FileSourceScan/BatchScan on a broadcast join's build side when the probe side is natively scannable, so the BroadcastExchange and the join run natively over the large probe. Gated by spark.comet.sparkToColumnar.broadcastBuildSide.enabled (default true) together with the Comet broadcast-exchange config. Guard the AQE DPP rule (convertSAB) against wrapping a non-native DPP subquery build in a CometBroadcastExchangeExec.

Which issue does this PR close?

Part of #6008.

Rationale for this change

An unsupported leaf scan (for example a Text file source, [COMET: Unsupported file format Text])
on the build side of a broadcast join cascades: the build branch (scan → transforms →
BroadcastExchange) stays on Spark, so the exchange never becomes a CometBroadcastExchangeExec,
so the BroadcastHashJoin can't go native — even when the large probe side is a fully native
scan+filter. A tiny lookup table read from an unsupported format disqualifies native execution of
the entire join over the big stream.

Comet already has a row→Arrow bridge (CometSparkToColumnarExec, delivered as a CometScanWrapper
that is a CometNativeExec), but it is off by default and its supportedOperatorList excludes file
scans, so this path was never hit. This PR auto-inserts that bridge at an unsupported build-side
scan — but only when doing so actually lets the join run natively — so the bounded, small build side
is adapted to Arrow and the join over the large probe input is accelerated.

What changes are included in this PR?

• New config spark.comet.sparkToColumnar.broadcastBuildSide.enabled (default true,
  CometConf.scala). Independent of the general spark.comet.sparkToColumnar.enabled opt-in.

• Auto-bridge on broadcast build sides (CometExecRule.scala): a pre-pass
  (tagBroadcastBuildSideLeaves) tags the build-side FileSourceScanExec/BatchScanExec of a
  BroadcastHashJoinExec/BroadcastNestedLoopJoinExec, and shouldApplySparkToColumnar then
  bridges a tagged scan — only in the unsupported-format arms, so the per-format
  spark.comet.convert.{csv,json,parquet}.enabled opt-outs still take precedence.
  The bridge is applied only when:

  • the feature config and spark.comet.exec.broadcastExchange.enabled are both on
    (otherwise the broadcast can't go native, so the bridge would be pointless), and
  • the probe side is already natively scannable (hasOnlyNativeScans) — i.e. the join can
    actually become a fully native CometBroadcastHashJoinExec. Bridging a build side under a join
    that stays on Spark is wasteful and would change the build broadcast's subtree, breaking Spark's
    dynamic-partition-pruning (DPP) broadcast reuse.
    The tag descent walks the dimension's own filters/projects/aggregations but stops at a nested
    join, so a large streamed input of a nested join inside the build side is not bridged.

• DPP guard (CometPlanAdaptiveDynamicPruningFilters.convertSAB): when the matched broadcast
  join is Comet, only build a CometBroadcastExchangeExec for the reused DPP subquery if that
  subquery's own build is native (isNativeBuildSide); otherwise fall back to a Spark
  BroadcastExchangeExec. This prevents an AQE+DPP crash
  (Comet execution only takes Arrow Arrays, but got ... OffHeapColumnVector) when the bridged
  dimension's separate DPP build copy is row-based. Mirrors the existing non-AQE guard in
  CometExecRule.rewriteInSubqueryPlan.

How are these changes tested?

• New unit tests in CometExecSuite (#6008), covering: a Text build side going native (AQE on
  and off); the broadcast-exchange-disabled gate; an unsupported scan below a build-side aggregate
  (and that the shuffle query stage is not bridged); the per-format opt-out still winning; a DSv2
  (BatchScanExec) build side; BuildLeft and BroadcastNestedLoopJoin variants; a non-native
  probe leaving the build side un-bridged; and an AQE+DPP regression test (text dimension + a
  partitioned Parquet fact) that pins the DPP guard. All assert result-equivalence to Spark via
  checkSparkAnswer/checkSparkAnswerAndOperator plus the expected plan shape.
• CometExecSuite passes on spark-4.1; the project builds on spark-4.0 and spark-4.1.
• The Spark SQL suite via dev/local-ci.sh spark sql_core-1 is green, including the
  DynamicPartitionPruning V1/V2 suites that guard broadcast/DPP reuse (an earlier eager version of
  this change regressed those; the probe-native gate + DPP guard fix it).

[andygrove]

This seems like a great idea. Also, CometSparkToColumnarExec got faster lately. I am kicking off a first pass AI review next.

[andygrove]

Thanks for this. Getting the join over the large probe side to run natively when a small lookup table is in a format Comet can't scan is a nice win. The ORC, Iceberg and text probes I ran all matched Spark. I did find three cases where the change makes an existing query slower than it is today, so I'm requesting changes for those. Details are inline. The new tests pass for me on 3.4, 3.5 and 4.2 as well.

Since this changes the planner, I've added run-spark-4.1-tests and run-all-spark-profiles. The local sql_core-1 run skips org.apache.spark.sql.execution.datasources.* and org.apache.spark.sql.connector.*, which run in sql_core-4. Those are the suites that cover ORC, text and V2 scans, and Hive ORC tables are covered in sql_hive. The profiles label runs the new tests on 3.4, where the DPP path is different.

docs/source/user-guide/latest/datasources.md still says these scans only convert with spark.comet.sparkToColumnar.enabled and the operator list. Could you add a paragraph there about the new default and how to turn it off?

The earlier [scans] failure was the listener race in the Iceberg write report test, which #6809 just fixed on main. The re-run passed.

[sunchao]

Summary

• Prior state and problem: An unsupported build-side scan prevented native broadcast joins even when the probe used a native scan. This PR enables that execution path automatically.
• Design approach: Tag eligible build-side scans before conversion, reuse CometSparkToColumnarExec, and guard AQE DPP broadcasts against non-Arrow inputs.
• Correctness: Reviewed the conversion, schema, input-file metadata, join eligibility and DPP paths against Spark sources. Existing join restrictions remain enforced. No additional introduced P1/P2 correctness issue was found beyond the previously reported blockers.
• Compatibility analysis: Compared relevant Spark sources for 3.4.3, 3.5.9, 4.0.4, 4.1.3 and 4.2.0. Spark's DPP reuse depends on matching broadcast plans. The new scan tagging conflicts with the existing Spark 3.4 fallback, as already reported. Compared the touched paths with branch-1.1 at e9efd9f764ee0a59b7898ff028d6985d4a7a28e1. Automatic conversion is intentional. Lost pruning and broadcast reuse are unintended regressions.
• Key design decisions: The feature defaults to enabled independently of general Spark-to-Arrow conversion. Broadcast-exchange conversion must also be enabled. CSV, JSON and Parquet conversion switches retain precedence, and tagging stops at nested joins.
• Implementation sketch: CometExecRule tags build-side file/V2 scans when the probe contains only recognized native scans. The existing bridge converts their output. CometPlanAdaptiveDynamicPruningFilters checks the DPP build separately before choosing its exchange type. Nine tests cover positive paths, configuration gates, aggregation, V2 scans, build orientation and DPP execution.
• Performance: Conversion copies scan output before filters and aggregates, so broadcast output size does not bound conversion work. The existing review substantiates lost pruning, retained conversions after join fallback, and duplicate DPP broadcasts. No benchmark establishes a net speedup for those cases, and I make no additional performance claim.
• Design: Reusing the existing bridge keeps the execution mechanism simple. However, native scan eligibility does not guarantee native join eligibility. The existing request to restore the build subtree when the join declines addresses that mismatch.
• Abstraction & complexity: The helpers are narrowly scoped and introduce no new execution framework. The new CometNativeExec test conflates class membership with Arrow-compatible output and excludes valid columnar operators such as CometUnionExec. This is covered by an existing blocker.
• Behavioral changes worth calling out: Eligible unsupported file and V2 scans can now feed native broadcast joins by default. DPP can execute a separate Spark broadcast for an unbridged dimension. The new AQE guard also affects existing native queries when the feature switch is disabled.
• Suggested improvements: Resolve the existing requests to honor the Spark 3.4 broadcast skip tag, undo conversions when a join declines, and recognize compatible Comet columnar DPP builds. Regression assertions should verify pruning and exchange reuse. No additional improvement meeting the P1/P2 reporting bar was identified.

Reviewed the full four-file PR diff for 8932aad407544a51fbfc38167c3bb46f29a67946 against supplied base e8c7ee739d3530b309d38388ba1c41decdb8abea, using merge base f9dd86d482d136426990186c2f1d42eef6a1ca59. GitHub's changed-file list matches this scope. The PR remains non-draft. Read the review, conversation comment, eight inline comments and eight unresolved threads before forming conclusions.

Routed skills: review-comet-pr and review-comet-ffi-pr. Also checked contributor guidance on FFI ownership, memory accounting, timezones, configuration, development and CI.

Existing blockers remain substantiated by the reported reproductions and source tracing: Spark 3.4 DPP loss, retained conversion and lost reuse after join fallback, and AQE DPP rejecting valid columnar builds. These are not duplicated as new findings.

Exact-head CI: Latest check runs associated with the reviewed SHA show 60 successes and 53 skips, with none failed or running. Comet suites passed across Spark 3.4–4.2, and all eight Spark 4.1 SQL/Hive shards passed. Retrieved execution logs confirm all nine new tests passed on 4.1. On 3.4, eight passed and the explicitly unsupported AQE DPP test was canceled. These jobs tested merge commits containing this head. The default job merged the supplied base, while the later profile run merged newer main.

Validation limits: No local JVM/native tests or benchmarks were run. This checkout has no compiled artifacts or Spark dependency cache. Runtime evidence comes from CI and the existing review's reproductions, corroborated by source inspection. macOS, dedicated Iceberg suites and other versions' full Spark SQL suites were skipped. git diff --check passed.

No additional introduced P1/P2 issues found within this review beyond the existing unresolved concerns.

[parthchandra]

Thank you for the review @andygrove. Addressed your comments and also added a paragraph to datasources.md about the new default and how to turn it off

[andygrove]

Thanks for the quick turnaround on these. I re-ran my probes against 3738210b84. The 3.4 fix works: with AQE the Iceberg fact reads 400 rows instead of 1000, and the broadcast is reused. The union dimension gets its ReusedExchange back under AQE, and turning off spark.comet.exec.broadcastHashJoin.enabled no longer leaves a bridge behind. The ORC and Iceberg probes still match Spark on 3.4 and 4.1.

The revert for joins that stay on Spark doesn't take effect yet, though. A FULL OUTER nested loop join still keeps the bridge under a Spark broadcast, and with DPP the dimension is still read twice. That's the slowdown from my first review, so I'm keeping the request for changes. Details are in the thread.

None of the three fixes has a test yet, so I've asked for one in each thread. CI is green, but none of the suites reaches the revert path.

[andygrove]

Thanks for reworking this. I re-ran my probes against 657044b7a2, on 4.1 and 3.4. Every join that stays on Spark now gets the same plan as with the feature off, with AQE on and off. That covers the FULL OUTER and build-left LEFT OUTER nested loop joins, aggregate and union build sides, and a probe side with an operator that stays on Spark. DPP over a join that declines scans the dimension once and reuses the broadcast again, and on 3.4 the native Iceberg fact still reads 400 rows. The new tests catch the regressions too. Turning off the clear fails the three no-bridge tests, the old CometNativeExec check fails the union test, and removing the skip check and the clear together fails the Iceberg DPP test on 3.4.

I've dismissed my earlier request for changes, since the bridge it was about is fixed. I left three more comments below that I'd like to see addressed before approving.

Dismissing this since the bridge left under a Spark broadcast is fixed in 657044b7a2. My remaining comments are in the new review.

[andygrove]

Thanks for the quick fixes. I re-ran my probes against 35a9aff95f on 3.4 and 4.1, and all three asks check out.

The CSV dimension no longer triggers the second transform. On the six-join query the count went from 94 to zero, and planning with the feature on now takes the same time as with it off, with AQE on and off.

The nested case keeps its bridge now. In the FULL OUTER nested loop join over a broadcast join of a Parquet table with a text table, the inner join runs as a CometBroadcastHashJoinExec, the outer join stays on Spark, and the answer matches Spark with AQE on and off. Every other shape I probed gives the same plan as last round, so the joins that stay on Spark still match the feature-off plan.

The renamed 3.4 test reads right to me now. I left two optional nits inline.

[andygrove]

Nit, optional: nothing in the PR pins this case. With it removed, every #6008 test still passes on 3.4, and the two that only run on 3.5+ have no nested join. My nested probe does catch it, because the inner join goes back to Spark. Could we add that shape to the Spark-staying tests? A FULL OUTER nested loop join whose build side is a broadcast join of a Parquet table with a text table would do. It could assert that the inner join is a CometBroadcastHashJoinExec with a CometSparkToColumnarExec under its CometBroadcastExchangeExec, and that the outer join stays a Spark BroadcastNestedLoopJoinExec.

[andygrove]

Nit, optional: the CometScanRule.scala:199 reference is my fault, since I quoted the line number. It will point at the wrong line after the next edit to that file. Could the comment name the check instead, for example the "AQE Dynamic Partition Pruning requires Spark 3.5+" fallback in CometScanRule.transformV1Scan?

[parthchandra]

@andygrove, thank you for the approval. Addressed your latest comments as well. Will wait for ci and any further comments.