Exam Bundle

This signal belongs to the adjacent case “A team enables acceleration but sees no benefit because source data scanning dominates,” whose remedy is Inspect scan and I/O metrics before adjusting compute again. The observed result for the present requirement is The selected compute meets the latency target with lower overall cost.

Physical scan bytes decrease without changing output columns needed would demonstrate the separate action Project only required columns and use a suitable columnar storage scan, which addresses “A repeated SQL query's latency is dominated by materialization of unnecessary columns.” It does not verify the requirement “A very small test workload pays increased startup overhead relative to compute time” following Benchmark total end-to-end runtime and choose appropriate compute size.

The physical plan shows fewer unsupported Python execution bottlenecks would demonstrate the separate action Use supported native expressions where feasible and inspect fallback stages, which addresses “A workload uses unsupported custom Python UDF logic that cannot run in Photon operators.” It does not verify the requirement “A very small test workload pays increased startup overhead relative to compute time” following Benchmark total end-to-end runtime and choose appropriate compute size.

Treat disk cache as an ephemeral executor-local optimization belongs to the separate case “A developer assumes disk cache permanently pins data across cluster replacement,” where A fresh cluster may require cold reads without correctness loss would be expected. That differs from the condition in this stem: “Repeat scans should reuse eligible locally cached remote file content.”

This action solves a different issue: “An important dataset must remain queryable even after cached worker nodes terminate.” Its normal signal is All table rows are readable from storage after a cluster restart. Here the requested behavior is “Repeat scans should reuse eligible locally cached remote file content,” so that signal is not sufficient.

Use `.cache()` or `.persist()` for the reused DataFrame and unpersist afterward belongs to the separate case “A Spark DataFrame is reused many times in one session and explicit compute caching is justified,” where Subsequent actions reuse cached partitions while memory consumption is bounded would be expected. That differs from the condition in this stem: “Repeat scans should reuse eligible locally cached remote file content.”

That observation is a valid indicator for “A Spark DataFrame is reused many times in one session and explicit compute caching is justified” when using Use `.cache()` or `.persist()` for the reused DataFrame and unpersist afterward. The scenario instead tests “Repeat scans should reuse eligible locally cached remote file content”; the relevant result is Repeated scans show improved remote I/O behavior on warm executors.

This signal belongs to the adjacent case “An important dataset must remain queryable even after cached worker nodes terminate,” whose remedy is Store the authoritative table in governed cloud object storage, not cache. The observed result for the present requirement is Repeated scans show improved remote I/O behavior on warm executors.

This signal belongs to the adjacent case “A developer assumes disk cache permanently pins data across cluster replacement,” whose remedy is Treat disk cache as an ephemeral executor-local optimization. The observed result for the present requirement is Repeated scans show improved remote I/O behavior on warm executors.

Store the authoritative table in governed cloud object storage, not cache is appropriate when “An important dataset must remain queryable even after cached worker nodes terminate”; it would be verified by All table rows are readable from storage after a cluster restart. It does not directly satisfy “A developer assumes disk cache permanently pins data across cluster replacement,” whose relevant acceptance evidence is A fresh cluster may require cold reads without correctness loss.

Use `.cache()` or `.persist()` for the reused DataFrame and unpersist afterward is appropriate when “A Spark DataFrame is reused many times in one session and explicit compute caching is justified”; it would be verified by Subsequent actions reuse cached partitions while memory consumption is bounded. It does not directly satisfy “A developer assumes disk cache permanently pins data across cluster replacement,” whose relevant acceptance evidence is A fresh cluster may require cold reads without correctness loss.

Use compute and access patterns supporting Databricks disk cache is appropriate when “Repeat scans should reuse eligible locally cached remote file content”; it would be verified by Repeated scans show improved remote I/O behavior on warm executors. It does not directly satisfy “A developer assumes disk cache permanently pins data across cluster replacement,” whose relevant acceptance evidence is A fresh cluster may require cold reads without correctness loss.

That observation is a valid indicator for “Repeat scans should reuse eligible locally cached remote file content” when using Use compute and access patterns supporting Databricks disk cache. The scenario instead tests “A developer assumes disk cache permanently pins data across cluster replacement”; the relevant result is A fresh cluster may require cold reads without correctness loss.

All table rows are readable from storage after a cluster restart pertains to a different control (Store the authoritative table in governed cloud object storage, not cache) and a different need (An important dataset must remain queryable even after cached worker nodes terminate). It cannot establish that Treat disk cache as an ephemeral executor-local optimization met the stated goal.

Subsequent actions reuse cached partitions while memory consumption is bounded would demonstrate the separate action Use `.cache()` or `.persist()` for the reused DataFrame and unpersist afterward, which addresses “A Spark DataFrame is reused many times in one session and explicit compute caching is justified.” It does not verify the requirement “A developer assumes disk cache permanently pins data across cluster replacement” following Treat disk cache as an ephemeral executor-local optimization.

This action solves a different issue: “A query shows little benefit from disk caching because every run reads new files.” Its normal signal is Measured remote read volume falls for the relevant recurring access pattern. Here the requested behavior is “An important dataset must remain queryable even after cached worker nodes terminate,” so that signal is not sufficient.

Use `.cache()` or `.persist()` for the reused DataFrame and unpersist afterward belongs to the separate case “A Spark DataFrame is reused many times in one session and explicit compute caching is justified,” where Subsequent actions reuse cached partitions while memory consumption is bounded would be expected. That differs from the condition in this stem: “An important dataset must remain queryable even after cached worker nodes terminate.”

Treat disk cache as an ephemeral executor-local optimization belongs to the separate case “A developer assumes disk cache permanently pins data across cluster replacement,” where A fresh cluster may require cold reads without correctness loss would be expected. That differs from the condition in this stem: “An important dataset must remain queryable even after cached worker nodes terminate.”

A fresh cluster may require cold reads without correctness loss pertains to a different control (Treat disk cache as an ephemeral executor-local optimization) and a different need (A developer assumes disk cache permanently pins data across cluster replacement). It cannot establish that Store the authoritative table in governed cloud object storage, not cache met the stated goal.

Subsequent actions reuse cached partitions while memory consumption is bounded pertains to a different control (Use `.cache()` or `.persist()` for the reused DataFrame and unpersist afterward) and a different need (A Spark DataFrame is reused many times in one session and explicit compute caching is justified). It cannot establish that Store the authoritative table in governed cloud object storage, not cache met the stated goal.

Repeated scans show improved remote I/O behavior on warm executors would demonstrate the separate action Use compute and access patterns supporting Databricks disk cache, which addresses “Repeat scans should reuse eligible locally cached remote file content.” It does not verify the requirement “An important dataset must remain queryable even after cached worker nodes terminate” following Store the authoritative table in governed cloud object storage, not cache.

The alternative Treat disk cache as an ephemeral executor-local optimization has a distinct purpose—A developer assumes disk cache permanently pins data across cluster replacement. It would not establish the required outcome (A Spark DataFrame is reused many times in one session and explicit compute caching is justified); the necessary verification concerns Subsequent actions reuse cached partitions while memory consumption is bounded.

This action solves a different issue: “An important dataset must remain queryable even after cached worker nodes terminate.” Its normal signal is All table rows are readable from storage after a cluster restart. Here the requested behavior is “A Spark DataFrame is reused many times in one session and explicit compute caching is justified,” so that signal is not sufficient.

The alternative Optimize data layout or query access before increasing disk cache settings has a distinct purpose—A query shows little benefit from disk caching because every run reads new files. It would not establish the required outcome (A Spark DataFrame is reused many times in one session and explicit compute caching is justified); the necessary verification concerns Subsequent actions reuse cached partitions while memory consumption is bounded.

Measured remote read volume falls for the relevant recurring access pattern would demonstrate the separate action Optimize data layout or query access before increasing disk cache settings, which addresses “A query shows little benefit from disk caching because every run reads new files.” It does not verify the requirement “A Spark DataFrame is reused many times in one session and explicit compute caching is justified” following Use `.cache()` or `.persist()` for the reused DataFrame and unpersist afterward.

All table rows are readable from storage after a cluster restart pertains to a different control (Store the authoritative table in governed cloud object storage, not cache) and a different need (An important dataset must remain queryable even after cached worker nodes terminate). It cannot establish that Use `.cache()` or `.persist()` for the reused DataFrame and unpersist afterward met the stated goal.

That observation is a valid indicator for “Repeat scans should reuse eligible locally cached remote file content” when using Use compute and access patterns supporting Databricks disk cache. The scenario instead tests “A Spark DataFrame is reused many times in one session and explicit compute caching is justified”; the relevant result is Subsequent actions reuse cached partitions while memory consumption is bounded.

Treat disk cache as an ephemeral executor-local optimization belongs to the separate case “A developer assumes disk cache permanently pins data across cluster replacement,” where A fresh cluster may require cold reads without correctness loss would be expected. That differs from the condition in this stem: “A query shows little benefit from disk caching because every run reads new files.”

This action solves a different issue: “An important dataset must remain queryable even after cached worker nodes terminate.” Its normal signal is All table rows are readable from storage after a cluster restart. Here the requested behavior is “A query shows little benefit from disk caching because every run reads new files,” so that signal is not sufficient.

The alternative Use `.cache()` or `.persist()` for the reused DataFrame and unpersist afterward has a distinct purpose—A Spark DataFrame is reused many times in one session and explicit compute caching is justified. It would not establish the required outcome (A query shows little benefit from disk caching because every run reads new files); the necessary verification concerns Measured remote read volume falls for the relevant recurring access pattern.

Subsequent actions reuse cached partitions while memory consumption is bounded would demonstrate the separate action Use `.cache()` or `.persist()` for the reused DataFrame and unpersist afterward, which addresses “A Spark DataFrame is reused many times in one session and explicit compute caching is justified.” It does not verify the requirement “A query shows little benefit from disk caching because every run reads new files” following Optimize data layout or query access before increasing disk cache settings.

This signal belongs to the adjacent case “A developer assumes disk cache permanently pins data across cluster replacement,” whose remedy is Treat disk cache as an ephemeral executor-local optimization. The observed result for the present requirement is Measured remote read volume falls for the relevant recurring access pattern.

That observation is a valid indicator for “An important dataset must remain queryable even after cached worker nodes terminate” when using Store the authoritative table in governed cloud object storage, not cache. The scenario instead tests “A query shows little benefit from disk caching because every run reads new files”; the relevant result is Measured remote read volume falls for the relevant recurring access pattern.