Exam Bundle

That observation is a valid indicator for “A small fraction of rows in large files are repeatedly deleted and full-file rewrites are expensive” when using Enable supported Delta deletion vectors where applicable. The scenario instead tests “A production ingestion MERGE is rewriting too many files for a tiny update set”; the relevant result is MERGE metrics show fewer rewritten bytes with correct target rows.

The consumer can read the table protocol without feature errors would demonstrate the separate action Choose compatible reader/runtime versions or disable incompatible features through supported migration, which addresses “A downstream reader cannot support a Delta table protocol feature used by deletion vectors.” It does not verify the requirement “A production ingestion MERGE is rewriting too many files for a tiny update set” following Investigate deletion vectors and data layout selection for efficient row-level modifications.

That observation is a valid indicator for “A row-level delete should remain transactionally consistent for concurrent readers” when using Execute a Delta DELETE or MERGE operation rather than editing Parquet files directly. The scenario instead tests “A production ingestion MERGE is rewriting too many files for a tiny update set”; the relevant result is MERGE metrics show fewer rewritten bytes with correct target rows.

The alternative Rebalance skew using supported AQE/skew mitigation or targeted salting has a distinct purpose—A join's keys are heavily skewed to one customer ID. It would not establish the required outcome (A small filtered dimension can fit into the broadcast threshold); the necessary verification concerns The physical plan broadcasts the small side and avoids the large shuffle.

Push semantically safe filters and projections ahead of the shuffle belongs to the separate case “A query shuffles a huge wide DataFrame before filtering unneeded rows,” where Shuffle input bytes and query runtime decrease would be expected. That differs from the condition in this stem: “A small filtered dimension can fit into the broadcast threshold.”

This action solves a different issue: “Two large datasets need a join and memory pressure makes forced broadcast impractical.” Its normal signal is The join completes without broadcast OOM and returns correct cardinality. Here the requested behavior is “A small filtered dimension can fit into the broadcast threshold,” so that signal is not sufficient.

This signal belongs to the adjacent case “A join's keys are heavily skewed to one customer ID,” whose remedy is Rebalance skew using supported AQE/skew mitigation or targeted salting. The observed result for the present requirement is The physical plan broadcasts the small side and avoids the large shuffle.

That observation is a valid indicator for “A query shuffles a huge wide DataFrame before filtering unneeded rows” when using Push semantically safe filters and projections ahead of the shuffle. The scenario instead tests “A small filtered dimension can fit into the broadcast threshold”; the relevant result is The physical plan broadcasts the small side and avoids the large shuffle.

Output row count and plan no longer contain unintended cross join would demonstrate the separate action Correct the equality/range join condition for the business keys, which addresses “The join creates a Cartesian product because the ON predicate was omitted.” It does not verify the requirement “A small filtered dimension can fit into the broadcast threshold” following Use an eligible broadcast join strategy or hint after verifying dimensions.

Push semantically safe filters and projections ahead of the shuffle is appropriate when “A query shuffles a huge wide DataFrame before filtering unneeded rows”; it would be verified by Shuffle input bytes and query runtime decrease. It does not directly satisfy “A join's keys are heavily skewed to one customer ID,” whose relevant acceptance evidence is Task durations become more uniform and the outlier partition shrinks.

Use an eligible broadcast join strategy or hint after verifying dimensions belongs to the separate case “A small filtered dimension can fit into the broadcast threshold,” where The physical plan broadcasts the small side and avoids the large shuffle would be expected. That differs from the condition in this stem: “A join's keys are heavily skewed to one customer ID.”

Allow a suitable sort-merge or supported shuffle join plan is appropriate when “Two large datasets need a join and memory pressure makes forced broadcast impractical”; it would be verified by The join completes without broadcast OOM and returns correct cardinality. It does not directly satisfy “A join's keys are heavily skewed to one customer ID,” whose relevant acceptance evidence is Task durations become more uniform and the outlier partition shrinks.

The join completes without broadcast OOM and returns correct cardinality pertains to a different control (Allow a suitable sort-merge or supported shuffle join plan) and a different need (Two large datasets need a join and memory pressure makes forced broadcast impractical). It cannot establish that Rebalance skew using supported AQE/skew mitigation or targeted salting met the stated goal.

That observation is a valid indicator for “A query shuffles a huge wide DataFrame before filtering unneeded rows” when using Push semantically safe filters and projections ahead of the shuffle. The scenario instead tests “A join's keys are heavily skewed to one customer ID”; the relevant result is Task durations become more uniform and the outlier partition shrinks.

The physical plan broadcasts the small side and avoids the large shuffle pertains to a different control (Use an eligible broadcast join strategy or hint after verifying dimensions) and a different need (A small filtered dimension can fit into the broadcast threshold). It cannot establish that Rebalance skew using supported AQE/skew mitigation or targeted salting met the stated goal.

The alternative Use an eligible broadcast join strategy or hint after verifying dimensions has a distinct purpose—A small filtered dimension can fit into the broadcast threshold. It would not establish the required outcome (The join creates a Cartesian product because the ON predicate was omitted); the necessary verification concerns Output row count and plan no longer contain unintended cross join.

The alternative Allow a suitable sort-merge or supported shuffle join plan has a distinct purpose—Two large datasets need a join and memory pressure makes forced broadcast impractical. It would not establish the required outcome (The join creates a Cartesian product because the ON predicate was omitted); the necessary verification concerns Output row count and plan no longer contain unintended cross join.

This action solves a different issue: “A query shuffles a huge wide DataFrame before filtering unneeded rows.” Its normal signal is Shuffle input bytes and query runtime decrease. Here the requested behavior is “The join creates a Cartesian product because the ON predicate was omitted,” so that signal is not sufficient.

That observation is a valid indicator for “Two large datasets need a join and memory pressure makes forced broadcast impractical” when using Allow a suitable sort-merge or supported shuffle join plan. The scenario instead tests “The join creates a Cartesian product because the ON predicate was omitted”; the relevant result is Output row count and plan no longer contain unintended cross join.

That observation is a valid indicator for “A join's keys are heavily skewed to one customer ID” when using Rebalance skew using supported AQE/skew mitigation or targeted salting. The scenario instead tests “The join creates a Cartesian product because the ON predicate was omitted”; the relevant result is Output row count and plan no longer contain unintended cross join.

The physical plan broadcasts the small side and avoids the large shuffle pertains to a different control (Use an eligible broadcast join strategy or hint after verifying dimensions) and a different need (A small filtered dimension can fit into the broadcast threshold). It cannot establish that Correct the equality/range join condition for the business keys met the stated goal.

Rebalance skew using supported AQE/skew mitigation or targeted salting is appropriate when “A join's keys are heavily skewed to one customer ID”; it would be verified by Task durations become more uniform and the outlier partition shrinks. It does not directly satisfy “A query shuffles a huge wide DataFrame before filtering unneeded rows,” whose relevant acceptance evidence is Shuffle input bytes and query runtime decrease.

Use an eligible broadcast join strategy or hint after verifying dimensions belongs to the separate case “A small filtered dimension can fit into the broadcast threshold,” where The physical plan broadcasts the small side and avoids the large shuffle would be expected. That differs from the condition in this stem: “A query shuffles a huge wide DataFrame before filtering unneeded rows.”

Correct the equality/range join condition for the business keys is appropriate when “The join creates a Cartesian product because the ON predicate was omitted”; it would be verified by Output row count and plan no longer contain unintended cross join. It does not directly satisfy “A query shuffles a huge wide DataFrame before filtering unneeded rows,” whose relevant acceptance evidence is Shuffle input bytes and query runtime decrease.

That observation is a valid indicator for “A small filtered dimension can fit into the broadcast threshold” when using Use an eligible broadcast join strategy or hint after verifying dimensions. The scenario instead tests “A query shuffles a huge wide DataFrame before filtering unneeded rows”; the relevant result is Shuffle input bytes and query runtime decrease.

Task durations become more uniform and the outlier partition shrinks would demonstrate the separate action Rebalance skew using supported AQE/skew mitigation or targeted salting, which addresses “A join's keys are heavily skewed to one customer ID.” It does not verify the requirement “A query shuffles a huge wide DataFrame before filtering unneeded rows” following Push semantically safe filters and projections ahead of the shuffle.

The join completes without broadcast OOM and returns correct cardinality pertains to a different control (Allow a suitable sort-merge or supported shuffle join plan) and a different need (Two large datasets need a join and memory pressure makes forced broadcast impractical). It cannot establish that Push semantically safe filters and projections ahead of the shuffle met the stated goal.

The alternative Push semantically safe filters and projections ahead of the shuffle has a distinct purpose—A query shuffles a huge wide DataFrame before filtering unneeded rows. It would not establish the required outcome (Two large datasets need a join and memory pressure makes forced broadcast impractical); the necessary verification concerns The join completes without broadcast OOM and returns correct cardinality.

Use an eligible broadcast join strategy or hint after verifying dimensions belongs to the separate case “A small filtered dimension can fit into the broadcast threshold,” where The physical plan broadcasts the small side and avoids the large shuffle would be expected. That differs from the condition in this stem: “Two large datasets need a join and memory pressure makes forced broadcast impractical.”

This action solves a different issue: “The join creates a Cartesian product because the ON predicate was omitted.” Its normal signal is Output row count and plan no longer contain unintended cross join. Here the requested behavior is “Two large datasets need a join and memory pressure makes forced broadcast impractical,” so that signal is not sufficient.

This signal belongs to the adjacent case “A join's keys are heavily skewed to one customer ID,” whose remedy is Rebalance skew using supported AQE/skew mitigation or targeted salting. The observed result for the present requirement is The join completes without broadcast OOM and returns correct cardinality.

That observation is a valid indicator for “The join creates a Cartesian product because the ON predicate was omitted” when using Correct the equality/range join condition for the business keys. The scenario instead tests “Two large datasets need a join and memory pressure makes forced broadcast impractical”; the relevant result is The join completes without broadcast OOM and returns correct cardinality.

That observation is a valid indicator for “A query shuffles a huge wide DataFrame before filtering unneeded rows” when using Push semantically safe filters and projections ahead of the shuffle. The scenario instead tests “Two large datasets need a join and memory pressure makes forced broadcast impractical”; the relevant result is The join completes without broadcast OOM and returns correct cardinality.