Exam Bundle

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.

The alternative Examine source arrival timestamps and downstream processing or serving delays has a distinct purpose—Streaming progress indicates no input backlog but high end-to-end event latency. It would not establish the required outcome (Microbatch duration exceeds configured trigger interval for several minutes); the necessary verification concerns Processed rows per second eventually exceed incoming rate.

Make `foreachBatch` sink operations idempotent and right-size write throughput is appropriate when “A streaming sink repeatedly retries due to expensive non-idempotent external writes”; it would be verified by Retries do not duplicate outputs and batch duration meets the SLA. It does not directly satisfy “Microbatch duration exceeds configured trigger interval for several minutes,” whose relevant acceptance evidence is Processed rows per second eventually exceed incoming rate.

This action solves a different issue: “Stateful joins consume excessive memory because event histories never expire.” Its normal signal is State rows stabilize while expected within-window matches remain. Here the requested behavior is “Microbatch duration exceeds configured trigger interval for several minutes,” so that signal is not sufficient.

Input file discovery and scheduling overhead decrease pertains to a different control (Use efficient file ingestion and compaction practices) and a different need (A streaming source has excessive tiny input files and metadata overhead). It cannot establish that Reduce per-batch work or add supported compute capacity rather than merely shorten triggers met the stated goal.

Latency budget attributes the delay to the correct segment pertains to a different control (Examine source arrival timestamps and downstream processing or serving delays) and a different need (Streaming progress indicates no input backlog but high end-to-end event latency). It cannot establish that Reduce per-batch work or add supported compute capacity rather than merely shorten triggers met the stated goal.

Retries do not duplicate outputs and batch duration meets the SLA pertains to a different control (Make `foreachBatch` sink operations idempotent and right-size write throughput) and a different need (A streaming sink repeatedly retries due to expensive non-idempotent external writes). It cannot establish that Reduce per-batch work or add supported compute capacity rather than merely shorten triggers met the stated goal.

The alternative Make `foreachBatch` sink operations idempotent and right-size write throughput has a distinct purpose—A streaming sink repeatedly retries due to expensive non-idempotent external writes. It would not establish the required outcome (Stateful joins consume excessive memory because event histories never expire); the necessary verification concerns State rows stabilize while expected within-window matches remain.

Use efficient file ingestion and compaction practices is appropriate when “A streaming source has excessive tiny input files and metadata overhead”; it would be verified by Input file discovery and scheduling overhead decrease. It does not directly satisfy “Stateful joins consume excessive memory because event histories never expire,” whose relevant acceptance evidence is State rows stabilize while expected within-window matches remain.

Examine source arrival timestamps and downstream processing or serving delays belongs to the separate case “Streaming progress indicates no input backlog but high end-to-end event latency,” where Latency budget attributes the delay to the correct segment would be expected. That differs from the condition in this stem: “Stateful joins consume excessive memory because event histories never expire.”

This signal belongs to the adjacent case “Streaming progress indicates no input backlog but high end-to-end event latency,” whose remedy is Examine source arrival timestamps and downstream processing or serving delays. The observed result for the present requirement is State rows stabilize while expected within-window matches remain.

This signal belongs to the adjacent case “A streaming sink repeatedly retries due to expensive non-idempotent external writes,” whose remedy is Make `foreachBatch` sink operations idempotent and right-size write throughput. The observed result for the present requirement is State rows stabilize while expected within-window matches remain.

Input file discovery and scheduling overhead decrease pertains to a different control (Use efficient file ingestion and compaction practices) and a different need (A streaming source has excessive tiny input files and metadata overhead). It cannot establish that Add appropriate watermarks and bounded join time ranges met the stated goal.

Add appropriate watermarks and bounded join time ranges is appropriate when “Stateful joins consume excessive memory because event histories never expire”; it would be verified by State rows stabilize while expected within-window matches remain. It does not directly satisfy “A streaming source has excessive tiny input files and metadata overhead,” whose relevant acceptance evidence is Input file discovery and scheduling overhead decrease.

The alternative Examine source arrival timestamps and downstream processing or serving delays has a distinct purpose—Streaming progress indicates no input backlog but high end-to-end event latency. It would not establish the required outcome (A streaming source has excessive tiny input files and metadata overhead); the necessary verification concerns Input file discovery and scheduling overhead decrease.

Make `foreachBatch` sink operations idempotent and right-size write throughput belongs to the separate case “A streaming sink repeatedly retries due to expensive non-idempotent external writes,” where Retries do not duplicate outputs and batch duration meets the SLA would be expected. That differs from the condition in this stem: “A streaming source has excessive tiny input files and metadata overhead.”

That observation is a valid indicator for “Stateful joins consume excessive memory because event histories never expire” when using Add appropriate watermarks and bounded join time ranges. The scenario instead tests “A streaming source has excessive tiny input files and metadata overhead”; the relevant result is Input file discovery and scheduling overhead decrease.

This signal belongs to the adjacent case “Microbatch duration exceeds configured trigger interval for several minutes,” whose remedy is Reduce per-batch work or add supported compute capacity rather than merely shorten triggers. The observed result for the present requirement is Input file discovery and scheduling overhead decrease.

This signal belongs to the adjacent case “Streaming progress indicates no input backlog but high end-to-end event latency,” whose remedy is Examine source arrival timestamps and downstream processing or serving delays. The observed result for the present requirement is Input file discovery and scheduling overhead decrease.

Reduce per-batch work or add supported compute capacity rather than merely shorten triggers belongs to the separate case “Microbatch duration exceeds configured trigger interval for several minutes,” where Processed rows per second eventually exceed incoming rate would be expected. That differs from the condition in this stem: “A streaming sink repeatedly retries due to expensive non-idempotent external writes.”

Use efficient file ingestion and compaction practices belongs to the separate case “A streaming source has excessive tiny input files and metadata overhead,” where Input file discovery and scheduling overhead decrease would be expected. That differs from the condition in this stem: “A streaming sink repeatedly retries due to expensive non-idempotent external writes.”

Add appropriate watermarks and bounded join time ranges belongs to the separate case “Stateful joins consume excessive memory because event histories never expire,” where State rows stabilize while expected within-window matches remain would be expected. That differs from the condition in this stem: “A streaming sink repeatedly retries due to expensive non-idempotent external writes.”

Latency budget attributes the delay to the correct segment pertains to a different control (Examine source arrival timestamps and downstream processing or serving delays) and a different need (Streaming progress indicates no input backlog but high end-to-end event latency). It cannot establish that Make `foreachBatch` sink operations idempotent and right-size write throughput met the stated goal.

Processed rows per second eventually exceed incoming rate pertains to a different control (Reduce per-batch work or add supported compute capacity rather than merely shorten triggers) and a different need (Microbatch duration exceeds configured trigger interval for several minutes). It cannot establish that Make `foreachBatch` sink operations idempotent and right-size write throughput met the stated goal.

This signal belongs to the adjacent case “A streaming source has excessive tiny input files and metadata overhead,” whose remedy is Use efficient file ingestion and compaction practices. The observed result for the present requirement is Retries do not duplicate outputs and batch duration meets the SLA.

The alternative Make `foreachBatch` sink operations idempotent and right-size write throughput has a distinct purpose—A streaming sink repeatedly retries due to expensive non-idempotent external writes. It would not establish the required outcome (Streaming progress indicates no input backlog but high end-to-end event latency); the necessary verification concerns Latency budget attributes the delay to the correct segment.

This action solves a different issue: “A streaming source has excessive tiny input files and metadata overhead.” Its normal signal is Input file discovery and scheduling overhead decrease. Here the requested behavior is “Streaming progress indicates no input backlog but high end-to-end event latency,” so that signal is not sufficient.

This action solves a different issue: “Microbatch duration exceeds configured trigger interval for several minutes.” Its normal signal is Processed rows per second eventually exceed incoming rate. Here the requested behavior is “Streaming progress indicates no input backlog but high end-to-end event latency,” so that signal is not sufficient.

Retries do not duplicate outputs and batch duration meets the SLA would demonstrate the separate action Make `foreachBatch` sink operations idempotent and right-size write throughput, which addresses “A streaming sink repeatedly retries due to expensive non-idempotent external writes.” It does not verify the requirement “Streaming progress indicates no input backlog but high end-to-end event latency” following Examine source arrival timestamps and downstream processing or serving delays.

State rows stabilize while expected within-window matches remain would demonstrate the separate action Add appropriate watermarks and bounded join time ranges, which addresses “Stateful joins consume excessive memory because event histories never expire.” It does not verify the requirement “Streaming progress indicates no input backlog but high end-to-end event latency” following Examine source arrival timestamps and downstream processing or serving delays.

Processed rows per second eventually exceed incoming rate pertains to a different control (Reduce per-batch work or add supported compute capacity rather than merely shorten triggers) and a different need (Microbatch duration exceeds configured trigger interval for several minutes). It cannot establish that Examine source arrival timestamps and downstream processing or serving delays met the stated goal.