Exam Bundle

The optimizer selects keys only when sufficient benefit is predicted pertains to a different control (Review predictive optimization eligibility and query workload instead of assuming an error) and a different need (A new liquid clustered table is created but no clustering keys were selected automatically). It cannot establish that Accept cost-aware optimizer selection rather than force arbitrary keys met the stated goal.

That observation is a valid indicator for “Queries filter on changing subsets of customer, date and region fields” when using Choose supported liquid clustering for the Delta table. The scenario instead tests “A very small table receives no automatic clustering keys despite configuration”; the relevant result is Optimizer avoids unnecessary rewrites when predicted benefit is negligible.

Automatic/manual maintenance targets tables with demonstrated query benefit pertains to a different control (Use cost-aware optimization policies rather than blanket frequent rewrites) and a different need (Maintenance cost is rising on tables rarely queried). It cannot establish that Accept cost-aware optimizer selection rather than force arbitrary keys met the stated goal.

Adjust output partitioning before writing within safe memory limits is appropriate when “A batch pipeline writes too many output files for its final dataset size”; it would be verified by The new batch produces a reasonable count of data files. It does not directly satisfy “Queries spend excessive time opening small files after frequent appends,” whose relevant acceptance evidence is File count falls and average file size increases.

The alternative Remove pathological partitioning and redesign data layout has a distinct purpose—A daily writer creates millions of tiny partitions from a high-cardinality identifier. It would not establish the required outcome (Queries spend excessive time opening small files after frequent appends); the necessary verification concerns File count falls and average file size increases.

This action solves a different issue: “A table needs to preserve transaction correctness during physical file compaction.” Its normal signal is Reads see consistent table versions before and after compaction. Here the requested behavior is “Queries spend excessive time opening small files after frequent appends,” so that signal is not sufficient.

This signal belongs to the adjacent case “Very large files cause poor parallelism for typical query scans,” whose remedy is Choose a balanced target file size and tune supported write optimization. The observed result for the present requirement is File count falls and average file size increases.

Reads see consistent table versions before and after compaction would demonstrate the separate action Use supported Delta OPTIMIZE rather than directly rewriting the data directory, which addresses “A table needs to preserve transaction correctness during physical file compaction.” It does not verify the requirement “Queries spend excessive time opening small files after frequent appends” following Run `OPTIMIZE` or enable supported automatic compaction.

The new batch produces a reasonable count of data files pertains to a different control (Adjust output partitioning before writing within safe memory limits) and a different need (A batch pipeline writes too many output files for its final dataset size). It cannot establish that Run `OPTIMIZE` or enable supported automatic compaction met the stated goal.

Run `OPTIMIZE` or enable supported automatic compaction is appropriate when “Queries spend excessive time opening small files after frequent appends”; it would be verified by File count falls and average file size increases. It does not directly satisfy “A daily writer creates millions of tiny partitions from a high-cardinality identifier,” whose relevant acceptance evidence is File counts drop and partition scans no longer explode.

Use supported Delta OPTIMIZE rather than directly rewriting the data directory belongs to the separate case “A table needs to preserve transaction correctness during physical file compaction,” where Reads see consistent table versions before and after compaction would be expected. That differs from the condition in this stem: “A daily writer creates millions of tiny partitions from a high-cardinality identifier.”

The alternative Choose a balanced target file size and tune supported write optimization has a distinct purpose—Very large files cause poor parallelism for typical query scans. It would not establish the required outcome (A daily writer creates millions of tiny partitions from a high-cardinality identifier); the necessary verification concerns File counts drop and partition scans no longer explode.

This signal belongs to the adjacent case “Very large files cause poor parallelism for typical query scans,” whose remedy is Choose a balanced target file size and tune supported write optimization. The observed result for the present requirement is File counts drop and partition scans no longer explode.

This signal belongs to the adjacent case “A table needs to preserve transaction correctness during physical file compaction,” whose remedy is Use supported Delta OPTIMIZE rather than directly rewriting the data directory. The observed result for the present requirement is File counts drop and partition scans no longer explode.

That observation is a valid indicator for “A batch pipeline writes too many output files for its final dataset size” when using Adjust output partitioning before writing within safe memory limits. The scenario instead tests “A daily writer creates millions of tiny partitions from a high-cardinality identifier”; the relevant result is File counts drop and partition scans no longer explode.

The alternative Remove pathological partitioning and redesign data layout has a distinct purpose—A daily writer creates millions of tiny partitions from a high-cardinality identifier. It would not establish the required outcome (A table needs to preserve transaction correctness during physical file compaction); the necessary verification concerns Reads see consistent table versions before and after compaction.

The alternative Choose a balanced target file size and tune supported write optimization has a distinct purpose—Very large files cause poor parallelism for typical query scans. It would not establish the required outcome (A table needs to preserve transaction correctness during physical file compaction); the necessary verification concerns Reads see consistent table versions before and after compaction.

The alternative Adjust output partitioning before writing within safe memory limits has a distinct purpose—A batch pipeline writes too many output files for its final dataset size. It would not establish the required outcome (A table needs to preserve transaction correctness during physical file compaction); the necessary verification concerns Reads see consistent table versions before and after compaction.

That observation is a valid indicator for “A daily writer creates millions of tiny partitions from a high-cardinality identifier” when using Remove pathological partitioning and redesign data layout. The scenario instead tests “A table needs to preserve transaction correctness during physical file compaction”; the relevant result is Reads see consistent table versions before and after compaction.

This signal belongs to the adjacent case “A batch pipeline writes too many output files for its final dataset size,” whose remedy is Adjust output partitioning before writing within safe memory limits. The observed result for the present requirement is Reads see consistent table versions before and after compaction.

Queries use enough scan tasks without excessive file-open overhead would demonstrate the separate action Choose a balanced target file size and tune supported write optimization, which addresses “Very large files cause poor parallelism for typical query scans.” It does not verify the requirement “A table needs to preserve transaction correctness during physical file compaction” following Use supported Delta OPTIMIZE rather than directly rewriting the data directory.

Run `OPTIMIZE` or enable supported automatic compaction belongs to the separate case “Queries spend excessive time opening small files after frequent appends,” where File count falls and average file size increases would be expected. That differs from the condition in this stem: “A batch pipeline writes too many output files for its final dataset size.”

This action solves a different issue: “Very large files cause poor parallelism for typical query scans.” Its normal signal is Queries use enough scan tasks without excessive file-open overhead. Here the requested behavior is “A batch pipeline writes too many output files for its final dataset size,” so that signal is not sufficient.

The alternative Use supported Delta OPTIMIZE rather than directly rewriting the data directory has a distinct purpose—A table needs to preserve transaction correctness during physical file compaction. It would not establish the required outcome (A batch pipeline writes too many output files for its final dataset size); the necessary verification concerns The new batch produces a reasonable count of data files.

Reads see consistent table versions before and after compaction would demonstrate the separate action Use supported Delta OPTIMIZE rather than directly rewriting the data directory, which addresses “A table needs to preserve transaction correctness during physical file compaction.” It does not verify the requirement “A batch pipeline writes too many output files for its final dataset size” following Adjust output partitioning before writing within safe memory limits.

Queries use enough scan tasks without excessive file-open overhead pertains to a different control (Choose a balanced target file size and tune supported write optimization) and a different need (Very large files cause poor parallelism for typical query scans). It cannot establish that Adjust output partitioning before writing within safe memory limits met the stated goal.

File counts drop and partition scans no longer explode would demonstrate the separate action Remove pathological partitioning and redesign data layout, which addresses “A daily writer creates millions of tiny partitions from a high-cardinality identifier.” It does not verify the requirement “A batch pipeline writes too many output files for its final dataset size” following Adjust output partitioning before writing within safe memory limits.

Remove pathological partitioning and redesign data layout is appropriate when “A daily writer creates millions of tiny partitions from a high-cardinality identifier”; it would be verified by File counts drop and partition scans no longer explode. It does not directly satisfy “Very large files cause poor parallelism for typical query scans,” whose relevant acceptance evidence is Queries use enough scan tasks without excessive file-open overhead.

The alternative Adjust output partitioning before writing within safe memory limits has a distinct purpose—A batch pipeline writes too many output files for its final dataset size. It would not establish the required outcome (Very large files cause poor parallelism for typical query scans); the necessary verification concerns Queries use enough scan tasks without excessive file-open overhead.

This action solves a different issue: “A table needs to preserve transaction correctness during physical file compaction.” Its normal signal is Reads see consistent table versions before and after compaction. Here the requested behavior is “Very large files cause poor parallelism for typical query scans,” so that signal is not sufficient.

This signal belongs to the adjacent case “Queries spend excessive time opening small files after frequent appends,” whose remedy is Run `OPTIMIZE` or enable supported automatic compaction. The observed result for the present requirement is Queries use enough scan tasks without excessive file-open overhead.

This signal belongs to the adjacent case “A daily writer creates millions of tiny partitions from a high-cardinality identifier,” whose remedy is Remove pathological partitioning and redesign data layout. The observed result for the present requirement is Queries use enough scan tasks without excessive file-open overhead.

Reads see consistent table versions before and after compaction would demonstrate the separate action Use supported Delta OPTIMIZE rather than directly rewriting the data directory, which addresses “A table needs to preserve transaction correctness during physical file compaction.” It does not verify the requirement “Very large files cause poor parallelism for typical query scans” following Choose a balanced target file size and tune supported write optimization.