Exam Bundle

This signal belongs to the adjacent case “A dashboard has frequent small queries and startup delay dominates response time,” whose remedy is Use an appropriately sized always-ready or short-autostop SQL warehouse for the SLO. The observed result for the present requirement is Measured SLO remains satisfied with lower billing usage.

BI query queue time improves while ETL completes independently would demonstrate the separate action Separate ETL compute from user-facing SQL workload capacity, which addresses “A scheduled heavy ETL job competes for slots with interactive BI users.” It does not verify the requirement “A workload is stable and an oversized warehouse wastes resources” following Downsize after benchmarking query durations and concurrency.

That observation is a valid indicator for “Peak interactive workload queues queries despite low individual query duration” when using Scale up or out eligible SQL warehouse capacity to match concurrency. The scenario instead tests “A workload is stable and an oversized warehouse wastes resources”; the relevant result is Measured SLO remains satisfied with lower billing usage.

Benchmark total end-to-end runtime and choose appropriate compute size belongs to the separate case “A very small test workload pays increased startup overhead relative to compute time,” where The selected compute meets the latency target with lower overall cost would be expected. That differs from the condition in this stem: “Large SQL analytic scans are CPU-bound under normal Spark engine execution.”

The alternative Inspect scan and I/O metrics before adjusting compute again has a distinct purpose—A team enables acceleration but sees no benefit because source data scanning dominates. It would not establish the required outcome (Large SQL analytic scans are CPU-bound under normal Spark engine execution); the necessary verification concerns Benchmark reports lower CPU time or execution latency with same results.

The alternative Project only required columns and use a suitable columnar storage scan has a distinct purpose—A repeated SQL query's latency is dominated by materialization of unnecessary columns. It would not establish the required outcome (Large SQL analytic scans are CPU-bound under normal Spark engine execution); the necessary verification concerns Benchmark reports lower CPU time or execution latency with same results.

That observation is a valid indicator for “A very small test workload pays increased startup overhead relative to compute time” when using Benchmark total end-to-end runtime and choose appropriate compute size. The scenario instead tests “Large SQL analytic scans are CPU-bound under normal Spark engine execution”; the relevant result is Benchmark reports lower CPU time or execution latency with same results.

This signal belongs to the adjacent case “A repeated SQL query's latency is dominated by materialization of unnecessary columns,” whose remedy is Project only required columns and use a suitable columnar storage scan. The observed result for the present requirement is Benchmark reports lower CPU time or execution latency with same results.

The bottleneck is attributed to read volume rather than engine computation would demonstrate the separate action Inspect scan and I/O metrics before adjusting compute again, which addresses “A team enables acceleration but sees no benefit because source data scanning dominates.” It does not verify the requirement “Large SQL analytic scans are CPU-bound under normal Spark engine execution” following Use eligible Photon-enabled compute for the workload.

Benchmark total end-to-end runtime and choose appropriate compute size is appropriate when “A very small test workload pays increased startup overhead relative to compute time”; it would be verified by The selected compute meets the latency target with lower overall cost. It does not directly satisfy “A workload uses unsupported custom Python UDF logic that cannot run in Photon operators,” whose relevant acceptance evidence is The physical plan shows fewer unsupported Python execution bottlenecks.

Inspect scan and I/O metrics before adjusting compute again belongs to the separate case “A team enables acceleration but sees no benefit because source data scanning dominates,” where The bottleneck is attributed to read volume rather than engine computation would be expected. That differs from the condition in this stem: “A workload uses unsupported custom Python UDF logic that cannot run in Photon operators.”

Use eligible Photon-enabled compute for the workload is appropriate when “Large SQL analytic scans are CPU-bound under normal Spark engine execution”; it would be verified by Benchmark reports lower CPU time or execution latency with same results. It does not directly satisfy “A workload uses unsupported custom Python UDF logic that cannot run in Photon operators,” whose relevant acceptance evidence is The physical plan shows fewer unsupported Python execution bottlenecks.

The bottleneck is attributed to read volume rather than engine computation would demonstrate the separate action Inspect scan and I/O metrics before adjusting compute again, which addresses “A team enables acceleration but sees no benefit because source data scanning dominates.” It does not verify the requirement “A workload uses unsupported custom Python UDF logic that cannot run in Photon operators” following Use supported native expressions where feasible and inspect fallback stages.

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

That observation is a valid indicator for “Large SQL analytic scans are CPU-bound under normal Spark engine execution” when using Use eligible Photon-enabled compute for the workload. The scenario instead tests “A workload uses unsupported custom Python UDF logic that cannot run in Photon operators”; the relevant result is The physical plan shows fewer unsupported Python execution bottlenecks.

The alternative Use supported native expressions where feasible and inspect fallback stages has a distinct purpose—A workload uses unsupported custom Python UDF logic that cannot run in Photon operators. It would not establish the required outcome (A team enables acceleration but sees no benefit because source data scanning dominates); the necessary verification concerns The bottleneck is attributed to read volume rather than engine computation.

This action solves a different issue: “A repeated SQL query's latency is dominated by materialization of unnecessary columns.” Its normal signal is Physical scan bytes decrease without changing output columns needed. Here the requested behavior is “A team enables acceleration but sees no benefit because source data scanning dominates,” so that signal is not sufficient.

This action solves a different issue: “Large SQL analytic scans are CPU-bound under normal Spark engine execution.” Its normal signal is Benchmark reports lower CPU time or execution latency with same results. Here the requested behavior is “A team enables acceleration but sees no benefit because source data scanning dominates,” so that signal is not sufficient.

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 team enables acceleration but sees no benefit because source data scanning dominates” following Inspect scan and I/O metrics before adjusting compute again.

That observation is a valid indicator for “A workload uses unsupported custom Python UDF logic that cannot run in Photon operators” when using Use supported native expressions where feasible and inspect fallback stages. The scenario instead tests “A team enables acceleration but sees no benefit because source data scanning dominates”; the relevant result is The bottleneck is attributed to read volume rather than engine computation.

Benchmark reports lower CPU time or execution latency with same results pertains to a different control (Use eligible Photon-enabled compute for the workload) and a different need (Large SQL analytic scans are CPU-bound under normal Spark engine execution). It cannot establish that Inspect scan and I/O metrics before adjusting compute again met the stated goal.

This action solves a different issue: “A workload uses unsupported custom Python UDF logic that cannot run in Photon operators.” Its normal signal is The physical plan shows fewer unsupported Python execution bottlenecks. Here the requested behavior is “A repeated SQL query's latency is dominated by materialization of unnecessary columns,” so that signal is not sufficient.

This action solves a different issue: “A team enables acceleration but sees no benefit because source data scanning dominates.” Its normal signal is The bottleneck is attributed to read volume rather than engine computation. Here the requested behavior is “A repeated SQL query's latency is dominated by materialization of unnecessary columns,” so that signal is not sufficient.

This action solves a different issue: “Large SQL analytic scans are CPU-bound under normal Spark engine execution.” Its normal signal is Benchmark reports lower CPU time or execution latency with same results. Here the requested behavior is “A repeated SQL query's latency is dominated by materialization of unnecessary columns,” so that signal is not sufficient.

That observation is a valid indicator for “A very small test workload pays increased startup overhead relative to compute time” when using Benchmark total end-to-end runtime and choose appropriate compute size. The scenario instead tests “A repeated SQL query's latency is dominated by materialization of unnecessary columns”; the relevant result is Physical scan bytes decrease without changing output columns needed.

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 Physical scan bytes decrease without changing output columns needed.

Benchmark reports lower CPU time or execution latency with same results pertains to a different control (Use eligible Photon-enabled compute for the workload) and a different need (Large SQL analytic scans are CPU-bound under normal Spark engine execution). It cannot establish that Project only required columns and use a suitable columnar storage scan met the stated goal.

This action solves a different issue: “A team enables acceleration but sees no benefit because source data scanning dominates.” Its normal signal is The bottleneck is attributed to read volume rather than engine computation. Here the requested behavior is “A very small test workload pays increased startup overhead relative to compute time,” so that signal is not sufficient.

The alternative Use supported native expressions where feasible and inspect fallback stages has a distinct purpose—A workload uses unsupported custom Python UDF logic that cannot run in Photon operators. It would not establish the required outcome (A very small test workload pays increased startup overhead relative to compute time); the necessary verification concerns The selected compute meets the latency target with lower overall cost.

The alternative Use eligible Photon-enabled compute for the workload has a distinct purpose—Large SQL analytic scans are CPU-bound under normal Spark engine execution. It would not establish the required outcome (A very small test workload pays increased startup overhead relative to compute time); the necessary verification concerns The selected compute meets the latency target with lower overall cost.

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.