Exam Bundle

That observation is a valid indicator for “A query wraps a partition/filter column in a nonpushdown-compatible function” when using Rewrite the predicate to a sargable equivalent while preserving semantics. The scenario instead tests “The table's data is well laid out but a query still performs full scans because no filter was supplied”; the relevant result is The plan shows pruning and returned records satisfy the intended subset.

Scan metrics show a lower percentage of files read would demonstrate the separate action Ensure relevant column statistics and appropriate data layout for pruning, which addresses “A query filters by an indexed or statistically tracked customer/date field.” It does not verify the requirement “The table's data is well laid out but a query still performs full scans because no filter was supplied” following Add a semantically correct selective WHERE condition to the query.

File count and selective scan cost decrease without partition explosion would demonstrate the separate action Use liquid clustering or suitable layout instead of one partition per key, which addresses “A high-cardinality filter benefits from clustering rather than massive Hive partitions.” It does not verify the requirement “The table's data is well laid out but a query still performs full scans because no filter was supplied” following Add a semantically correct selective WHERE condition to the query.

Investigate deletion vectors and data layout selection for efficient row-level modifications is appropriate when “A production ingestion MERGE is rewriting too many files for a tiny update set”; it would be verified by MERGE metrics show fewer rewritten bytes with correct target rows. It does not directly satisfy “A small fraction of rows in large files are repeatedly deleted and full-file rewrites are expensive,” whose relevant acceptance evidence is Delete commits can mark rows without always rewriting complete data files.

Choose compatible reader/runtime versions or disable incompatible features through supported migration belongs to the separate case “A downstream reader cannot support a Delta table protocol feature used by deletion vectors,” where The consumer can read the table protocol without feature errors would be expected. That differs from the condition in this stem: “A small fraction of rows in large files are repeatedly deleted and full-file rewrites are expensive.”

The alternative Execute a Delta DELETE or MERGE operation rather than editing Parquet files directly has a distinct purpose—A row-level delete should remain transactionally consistent for concurrent readers. It would not establish the required outcome (A small fraction of rows in large files are repeatedly deleted and full-file rewrites are expensive); the necessary verification concerns Delete commits can mark rows without always rewriting complete data files.

That observation is a valid indicator for “Physical files contain logically deleted rows and must eventually be purged under compliance policy” when using Run supported rewrite/maintenance plus appropriate retention-safe VACUUM where required. The scenario instead tests “A small fraction of rows in large files are repeatedly deleted and full-file rewrites are expensive”; the relevant result is Delete commits can mark rows without always rewriting complete data files.

Readers observe the correct committed row set after the transaction would demonstrate the separate action Execute a Delta DELETE or MERGE operation rather than editing Parquet files directly, which addresses “A row-level delete should remain transactionally consistent for concurrent readers.” It does not verify the requirement “A small fraction of rows in large files are repeatedly deleted and full-file rewrites are expensive” following Enable supported Delta deletion vectors where applicable.

That observation is a valid indicator for “A production ingestion MERGE is rewriting too many files for a tiny update set” when using Investigate deletion vectors and data layout selection for efficient row-level modifications. The scenario instead tests “A small fraction of rows in large files are repeatedly deleted and full-file rewrites are expensive”; the relevant result is Delete commits can mark rows without always rewriting complete data files.

Run supported rewrite/maintenance plus appropriate retention-safe VACUUM where required is appropriate when “Physical files contain logically deleted rows and must eventually be purged under compliance policy”; it would be verified by Purged rows no longer reside in reachable retained files after the governed process. It does not directly satisfy “A downstream reader cannot support a Delta table protocol feature used by deletion vectors,” whose relevant acceptance evidence is The consumer can read the table protocol without feature errors.

This action solves a different issue: “A row-level delete should remain transactionally consistent for concurrent readers.” Its normal signal is Readers observe the correct committed row set after the transaction. Here the requested behavior is “A downstream reader cannot support a Delta table protocol feature used by deletion vectors,” so that signal is not sufficient.

The alternative Investigate deletion vectors and data layout selection for efficient row-level modifications has a distinct purpose—A production ingestion MERGE is rewriting too many files for a tiny update set. It would not establish the required outcome (A downstream reader cannot support a Delta table protocol feature used by deletion vectors); the necessary verification concerns The consumer can read the table protocol without feature errors.

This signal belongs to the adjacent case “A row-level delete should remain transactionally consistent for concurrent readers,” whose remedy is Execute a Delta DELETE or MERGE operation rather than editing Parquet files directly. The observed result for the present requirement is The consumer can read the table protocol without feature errors.

Purged rows no longer reside in reachable retained files after the governed process pertains to a different control (Run supported rewrite/maintenance plus appropriate retention-safe VACUUM where required) and a different need (Physical files contain logically deleted rows and must eventually be purged under compliance policy). It cannot establish that Choose compatible reader/runtime versions or disable incompatible features through supported migration met the stated goal.

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

This action solves a different issue: “A downstream reader cannot support a Delta table protocol feature used by deletion vectors.” Its normal signal is The consumer can read the table protocol without feature errors. Here the requested behavior is “A row-level delete should remain transactionally consistent for concurrent readers,” so that signal is not sufficient.

Investigate deletion vectors and data layout selection for efficient row-level modifications belongs to the separate case “A production ingestion MERGE is rewriting too many files for a tiny update set,” where MERGE metrics show fewer rewritten bytes with correct target rows would be expected. That differs from the condition in this stem: “A row-level delete should remain transactionally consistent for concurrent readers.”

Run supported rewrite/maintenance plus appropriate retention-safe VACUUM where required belongs to the separate case “Physical files contain logically deleted rows and must eventually be purged under compliance policy,” where Purged rows no longer reside in reachable retained files after the governed process would be expected. That differs from the condition in this stem: “A row-level delete should remain transactionally consistent for concurrent readers.”

Purged rows no longer reside in reachable retained files after the governed process would demonstrate the separate action Run supported rewrite/maintenance plus appropriate retention-safe VACUUM where required, which addresses “Physical files contain logically deleted rows and must eventually be purged under compliance policy.” It does not verify the requirement “A row-level delete should remain transactionally consistent for concurrent readers” following Execute a Delta DELETE or MERGE operation rather than editing Parquet files directly.

This signal belongs to the adjacent case “A downstream reader cannot support a Delta table protocol feature used by deletion vectors,” whose remedy is Choose compatible reader/runtime versions or disable incompatible features through supported migration. The observed result for the present requirement is Readers observe the correct committed row set after the transaction.

MERGE metrics show fewer rewritten bytes with correct target rows would demonstrate the separate action Investigate deletion vectors and data layout selection for efficient row-level modifications, which addresses “A production ingestion MERGE is rewriting too many files for a tiny update set.” It does not verify the requirement “A row-level delete should remain transactionally consistent for concurrent readers” following Execute a Delta DELETE or MERGE operation rather than editing Parquet files directly.

Investigate deletion vectors and data layout selection for efficient row-level modifications belongs to the separate case “A production ingestion MERGE is rewriting too many files for a tiny update set,” where MERGE metrics show fewer rewritten bytes with correct target rows would be expected. That differs from the condition in this stem: “Physical files contain logically deleted rows and must eventually be purged under compliance policy.”

This action solves a different issue: “A row-level delete should remain transactionally consistent for concurrent readers.” Its normal signal is Readers observe the correct committed row set after the transaction. Here the requested behavior is “Physical files contain logically deleted rows and must eventually be purged under compliance policy,” so that signal is not sufficient.

Choose compatible reader/runtime versions or disable incompatible features through supported migration belongs to the separate case “A downstream reader cannot support a Delta table protocol feature used by deletion vectors,” where The consumer can read the table protocol without feature errors would be expected. That differs from the condition in this stem: “Physical files contain logically deleted rows and must eventually be purged under compliance policy.”

Delete commits can mark rows without always rewriting complete data files pertains to a different control (Enable supported Delta deletion vectors where applicable) and a different need (A small fraction of rows in large files are repeatedly deleted and full-file rewrites are expensive). It cannot establish that Run supported rewrite/maintenance plus appropriate retention-safe VACUUM where required met the stated goal.

Readers observe the correct committed row set after the transaction pertains to a different control (Execute a Delta DELETE or MERGE operation rather than editing Parquet files directly) and a different need (A row-level delete should remain transactionally consistent for concurrent readers). It cannot establish that Run supported rewrite/maintenance plus appropriate retention-safe VACUUM where required met the stated goal.

That observation is a valid indicator for “A production ingestion MERGE is rewriting too many files for a tiny update set” when using Investigate deletion vectors and data layout selection for efficient row-level modifications. The scenario instead tests “Physical files contain logically deleted rows and must eventually be purged under compliance policy”; the relevant result is Purged rows no longer reside in reachable retained files after the governed process.

Choose compatible reader/runtime versions or disable incompatible features through supported migration belongs to the separate case “A downstream reader cannot support a Delta table protocol feature used by deletion vectors,” where The consumer can read the table protocol without feature errors would be expected. That differs from the condition in this stem: “A production ingestion MERGE is rewriting too many files for a tiny update set.”

This action solves a different issue: “A row-level delete should remain transactionally consistent for concurrent readers.” Its normal signal is Readers observe the correct committed row set after the transaction. Here the requested behavior is “A production ingestion MERGE is rewriting too many files for a tiny update set,” so that signal is not sufficient.

The alternative Run supported rewrite/maintenance plus appropriate retention-safe VACUUM where required has a distinct purpose—Physical files contain logically deleted rows and must eventually be purged under compliance policy. It would not establish the required outcome (A production ingestion MERGE is rewriting too many files for a tiny update set); the necessary verification concerns MERGE metrics show fewer rewritten bytes with correct target rows.

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.