Exam Bundle

Every trigger publishes the full current result table pertains to a different control (Use complete output mode where supported for the aggregation) and a different need (A full small aggregation result must be rewritten each trigger and its sink supports that mode). It cannot establish that Use append output mode for the event stream met the stated goal.

New records accumulate exactly once at supported sink boundaries after restart pertains to a different control (Use an append-compatible Delta streaming write with checkpointing) and a different need (A streaming Delta sink must accept new append rows and preserve committed offsets). It cannot establish that Use append output mode for the event stream met the stated goal.

Changes to active group aggregates are emitted on each trigger pertains to a different control (Use update output mode where supported) and a different need (A dashboard needs updated values for incomplete aggregation groups after each microbatch). It cannot establish that Use append output mode for the event stream met the stated goal.

This action solves a different issue: “Microbatch processing unexpectedly skips later records because the consumer ignores part of the batch.” Its normal signal is Subsequent microbatches proceed without incomplete-state errors. Here the requested behavior is “A custom MERGE must execute for every streaming microbatch with batch semantics,” so that signal is not sufficient.

The alternative Store or use the microbatch ID to make downstream operations idempotent has a distinct purpose—A retried microbatch may repeat external side effects. It would not establish the required outcome (A custom MERGE must execute for every streaming microbatch with batch semantics); the necessary verification concerns A new microbatch updates and inserts only the intended keys.

The alternative Implement its own idempotency or transactional deduplication at the sink has a distinct purpose—An application uses `foreachBatch` but assumes exactly-once by default for every external sink. It would not establish the required outcome (A custom MERGE must execute for every streaming microbatch with batch semantics); the necessary verification concerns A new microbatch updates and inserts only the intended keys.

That observation is a valid indicator for “A retried microbatch may repeat external side effects” when using Store or use the microbatch ID to make downstream operations idempotent. The scenario instead tests “A custom MERGE must execute for every streaming microbatch with batch semantics”; the relevant result is A new microbatch updates and inserts only the intended keys.

This signal belongs to the adjacent case “A pipeline must feed two independently managed sinks from one incoming microbatch,” whose remedy is Handle both sinks inside a controlled `foreachBatch` function with independent idempotent writes. The observed result for the present requirement is A new microbatch updates and inserts only the intended keys.

An injected retry leaves the sink with one logical result per source key pertains to a different control (Implement its own idempotency or transactional deduplication at the sink) and a different need (An application uses `foreachBatch` but assumes exactly-once by default for every external sink). It cannot establish that Use `foreachBatch` to invoke a batch MERGE for each microbatch DataFrame met the stated goal.

The alternative Ensure the batch handler consumes all input needed by the stateful source has a distinct purpose—Microbatch processing unexpectedly skips later records because the consumer ignores part of the batch. It would not establish the required outcome (A retried microbatch may repeat external side effects); the necessary verification concerns Running the same batch twice does not create duplicate sink effects.

The alternative Handle both sinks inside a controlled `foreachBatch` function with independent idempotent writes has a distinct purpose—A pipeline must feed two independently managed sinks from one incoming microbatch. It would not establish the required outcome (A retried microbatch may repeat external side effects); the necessary verification concerns Running the same batch twice does not create duplicate sink effects.

Implement its own idempotency or transactional deduplication at the sink is appropriate when “An application uses `foreachBatch` but assumes exactly-once by default for every external sink”; it would be verified by An injected retry leaves the sink with one logical result per source key. It does not directly satisfy “A retried microbatch may repeat external side effects,” whose relevant acceptance evidence is Running the same batch twice does not create duplicate sink effects.

A new microbatch updates and inserts only the intended keys pertains to a different control (Use `foreachBatch` to invoke a batch MERGE for each microbatch DataFrame) and a different need (A custom MERGE must execute for every streaming microbatch with batch semantics). It cannot establish that Store or use the microbatch ID to make downstream operations idempotent met the stated goal.

An injected retry leaves the sink with one logical result per source key would demonstrate the separate action Implement its own idempotency or transactional deduplication at the sink, which addresses “An application uses `foreachBatch` but assumes exactly-once by default for every external sink.” It does not verify the requirement “A retried microbatch may repeat external side effects” following Store or use the microbatch ID to make downstream operations idempotent.

Subsequent microbatches proceed without incomplete-state errors pertains to a different control (Ensure the batch handler consumes all input needed by the stateful source) and a different need (Microbatch processing unexpectedly skips later records because the consumer ignores part of the batch). It cannot establish that Store or use the microbatch ID to make downstream operations idempotent met the stated goal.

Implement its own idempotency or transactional deduplication at the sink belongs to the separate case “An application uses `foreachBatch` but assumes exactly-once by default for every external sink,” where An injected retry leaves the sink with one logical result per source key would be expected. That differs from the condition in this stem: “Microbatch processing unexpectedly skips later records because the consumer ignores part of the batch.”

Handle both sinks inside a controlled `foreachBatch` function with independent idempotent writes belongs to the separate case “A pipeline must feed two independently managed sinks from one incoming microbatch,” where Each sink reaches its expected record state even if a batch is retried would be expected. That differs from the condition in this stem: “Microbatch processing unexpectedly skips later records because the consumer ignores part of the batch.”

The alternative Use `foreachBatch` to invoke a batch MERGE for each microbatch DataFrame has a distinct purpose—A custom MERGE must execute for every streaming microbatch with batch semantics. It would not establish the required outcome (Microbatch processing unexpectedly skips later records because the consumer ignores part of the batch); the necessary verification concerns Subsequent microbatches proceed without incomplete-state errors.

An injected retry leaves the sink with one logical result per source key pertains to a different control (Implement its own idempotency or transactional deduplication at the sink) and a different need (An application uses `foreachBatch` but assumes exactly-once by default for every external sink). It cannot establish that Ensure the batch handler consumes all input needed by the stateful source met the stated goal.

Running the same batch twice does not create duplicate sink effects would demonstrate the separate action Store or use the microbatch ID to make downstream operations idempotent, which addresses “A retried microbatch may repeat external side effects.” It does not verify the requirement “Microbatch processing unexpectedly skips later records because the consumer ignores part of the batch” following Ensure the batch handler consumes all input needed by the stateful source.

This signal belongs to the adjacent case “A pipeline must feed two independently managed sinks from one incoming microbatch,” whose remedy is Handle both sinks inside a controlled `foreachBatch` function with independent idempotent writes. The observed result for the present requirement is Subsequent microbatches proceed without incomplete-state errors.

Implement its own idempotency or transactional deduplication at the sink is appropriate when “An application uses `foreachBatch` but assumes exactly-once by default for every external sink”; it would be verified by An injected retry leaves the sink with one logical result per source key. It does not directly satisfy “A pipeline must feed two independently managed sinks from one incoming microbatch,” whose relevant acceptance evidence is Each sink reaches its expected record state even if a batch is retried.

Use `foreachBatch` to invoke a batch MERGE for each microbatch DataFrame belongs to the separate case “A custom MERGE must execute for every streaming microbatch with batch semantics,” where A new microbatch updates and inserts only the intended keys would be expected. That differs from the condition in this stem: “A pipeline must feed two independently managed sinks from one incoming microbatch.”

The alternative Ensure the batch handler consumes all input needed by the stateful source has a distinct purpose—Microbatch processing unexpectedly skips later records because the consumer ignores part of the batch. It would not establish the required outcome (A pipeline must feed two independently managed sinks from one incoming microbatch); the necessary verification concerns Each sink reaches its expected record state even if a batch is retried.

An injected retry leaves the sink with one logical result per source key would demonstrate the separate action Implement its own idempotency or transactional deduplication at the sink, which addresses “An application uses `foreachBatch` but assumes exactly-once by default for every external sink.” It does not verify the requirement “A pipeline must feed two independently managed sinks from one incoming microbatch” following Handle both sinks inside a controlled `foreachBatch` function with independent idempotent writes.

That observation is a valid indicator for “A retried microbatch may repeat external side effects” when using Store or use the microbatch ID to make downstream operations idempotent. The scenario instead tests “A pipeline must feed two independently managed sinks from one incoming microbatch”; the relevant result is Each sink reaches its expected record state even if a batch is retried.

A new microbatch updates and inserts only the intended keys would demonstrate the separate action Use `foreachBatch` to invoke a batch MERGE for each microbatch DataFrame, which addresses “A custom MERGE must execute for every streaming microbatch with batch semantics.” It does not verify the requirement “A pipeline must feed two independently managed sinks from one incoming microbatch” following Handle both sinks inside a controlled `foreachBatch` function with independent idempotent writes.

This action solves a different issue: “A pipeline must feed two independently managed sinks from one incoming microbatch.” Its normal signal is Each sink reaches its expected record state even if a batch is retried. Here the requested behavior is “An application uses `foreachBatch` but assumes exactly-once by default for every external sink,” so that signal is not sufficient.

Use `foreachBatch` to invoke a batch MERGE for each microbatch DataFrame belongs to the separate case “A custom MERGE must execute for every streaming microbatch with batch semantics,” where A new microbatch updates and inserts only the intended keys would be expected. That differs from the condition in this stem: “An application uses `foreachBatch` but assumes exactly-once by default for every external sink.”

The alternative Store or use the microbatch ID to make downstream operations idempotent has a distinct purpose—A retried microbatch may repeat external side effects. It would not establish the required outcome (An application uses `foreachBatch` but assumes exactly-once by default for every external sink); the necessary verification concerns An injected retry leaves the sink with one logical result per source key.

That observation is a valid indicator for “A retried microbatch may repeat external side effects” when using Store or use the microbatch ID to make downstream operations idempotent. The scenario instead tests “An application uses `foreachBatch` but assumes exactly-once by default for every external sink”; the relevant result is An injected retry leaves the sink with one logical result per source key.

That observation is a valid indicator for “Microbatch processing unexpectedly skips later records because the consumer ignores part of the batch” when using Ensure the batch handler consumes all input needed by the stateful source. The scenario instead tests “An application uses `foreachBatch` but assumes exactly-once by default for every external sink”; the relevant result is An injected retry leaves the sink with one logical result per source key.

This signal belongs to the adjacent case “A custom MERGE must execute for every streaming microbatch with batch semantics,” whose remedy is Use `foreachBatch` to invoke a batch MERGE for each microbatch DataFrame. The observed result for the present requirement is An injected retry leaves the sink with one logical result per source key.