Exam Bundle

That observation is a valid indicator for “A built-in SQL expression can normalize a simple string column” when using Use the Spark SQL built-in function rather than introducing a Python UDF. The scenario instead tests “A custom function should be callable by analysts from supported SQL workloads with governed permissions”; the relevant result is Authorized SQL users can invoke the function while unauthorized users cannot.

The output column matches expected unit-test values and schema pertains to a different control (Register and call a standard Python UDF with explicit output type) and a different need (A custom row transformation is required and a plain scalar Python UDF is the simplest supported choice). It cannot establish that Create a suitable Unity Catalog SQL function and grant EXECUTE where needed met the stated goal.

This signal belongs to the adjacent case “A vectorizable numerical transformation needs batch processing through Arrow-compatible pandas objects,” whose remedy is Use an appropriate pandas UDF with declared return type. The observed result for the present requirement is Authorized SQL users can invoke the function while unauthorized users cannot.

Use a materialized view with the desired declarative query is appropriate when “A daily dashboard needs a recomputed aggregate over upstream data”; it would be verified by The materialized view reflects the correct aggregate after its refresh. It does not directly satisfy “Every new event must be incrementally appended into a continuously maintained target,” whose relevant acceptance evidence is A pipeline update advances the streaming table while retaining its checkpointed progress.

Configure suitable pipeline updates and materialized view refresh belongs to the separate case “A materialized view is required to be refreshed by a pipeline schedule rather than on every source event,” where The refreshed snapshot reflects data available by the update time would be expected. That differs from the condition in this stem: “Every new event must be incrementally appended into a continuously maintained target.”

Use `foreachBatch` to invoke a batch MERGE for each microbatch DataFrame is appropriate when “A custom MERGE must execute for every streaming microbatch with batch semantics”; it would be verified by A new microbatch updates and inserts only the intended keys. It does not directly satisfy “Every new event must be incrementally appended into a continuously maintained target,” whose relevant acceptance evidence is A pipeline update advances the streaming table while retaining its checkpointed progress.

That observation is a valid indicator for “A daily dashboard needs a recomputed aggregate over upstream data” when using Use a materialized view with the desired declarative query. The scenario instead tests “Every new event must be incrementally appended into a continuously maintained target”; the relevant result is A pipeline update advances the streaming table while retaining its checkpointed progress.

This signal belongs to the adjacent case “A materialized view is required to be refreshed by a pipeline schedule rather than on every source event,” whose remedy is Configure suitable pipeline updates and materialized view refresh. The observed result for the present requirement is A pipeline update advances the streaming table while retaining its checkpointed progress.

That observation is a valid indicator for “Per-customer latest event is needed while retaining the full winning row” when using Use `ROW_NUMBER()` with `PARTITION BY customer_id` and deterministic order. The scenario instead tests “Every new event must be incrementally appended into a continuously maintained target”; the relevant result is A pipeline update advances the streaming table while retaining its checkpointed progress.

The alternative Use a materialized view rather than forcing unsupported incremental stream semantics has a distinct purpose—A refreshed aggregate has nonincremental SQL operations over several inputs. It would not establish the required outcome (A daily dashboard needs a recomputed aggregate over upstream data); the necessary verification concerns The materialized view reflects the correct aggregate after its refresh.

Use the supported pipelines Python decorator for a materialized view function belongs to the separate case “A Python pipeline definition should register a managed materialized view with declarative SQL,” where The pipeline DAG contains the materialized view and its dataset is refreshed would be expected. That differs from the condition in this stem: “A daily dashboard needs a recomputed aggregate over upstream data.”

Read the incremental source into a streaming table instead of overwriting a static table is appropriate when “A target needs append-only ingestion rather than destructive daily replacement”; it would be verified by A second update adds new source rows without replacing prior accepted rows. It does not directly satisfy “A daily dashboard needs a recomputed aggregate over upstream data,” whose relevant acceptance evidence is The materialized view reflects the correct aggregate after its refresh.

A second update adds new source rows without replacing prior accepted rows would demonstrate the separate action Read the incremental source into a streaming table instead of overwriting a static table, which addresses “A target needs append-only ingestion rather than destructive daily replacement.” It does not verify the requirement “A daily dashboard needs a recomputed aggregate over upstream data” following Use a materialized view with the desired declarative query.

That observation is a valid indicator for “A refreshed aggregate has nonincremental SQL operations over several inputs” when using Use a materialized view rather than forcing unsupported incremental stream semantics. The scenario instead tests “A daily dashboard needs a recomputed aggregate over upstream data”; the relevant result is The materialized view reflects the correct aggregate after its refresh.

The notification task runs under the intended upstream result condition pertains to a different control (Configure appropriate task run-if behavior for the notification) and a different need (A notification task must run after upstream processing fails or succeeds). It cannot establish that Use a materialized view with the desired declarative query met the stated goal.

The alternative Use the supported pipelines Python decorator for a materialized view function has a distinct purpose—A Python pipeline definition should register a managed materialized view with declarative SQL. It would not establish the required outcome (A stream source is being consumed with an operation that is unsupported incrementally); the necessary verification concerns The pipeline runs without unsupported streaming operation failures.

Read the incremental source into a streaming table instead of overwriting a static table belongs to the separate case “A target needs append-only ingestion rather than destructive daily replacement,” where A second update adds new source rows without replacing prior accepted rows would be expected. That differs from the condition in this stem: “A stream source is being consumed with an operation that is unsupported incrementally.”

Use a streaming table backed by the incremental ingestion stream belongs to the separate case “A continuous ingestion target should read new records incrementally using file notifications,” where The streaming table advances without rereading all existing files would be expected. That differs from the condition in this stem: “A stream source is being consumed with an operation that is unsupported incrementally.”

This signal belongs to the adjacent case “A continuous ingestion target should read new records incrementally using file notifications,” whose remedy is Use a streaming table backed by the incremental ingestion stream. The observed result for the present requirement is The pipeline runs without unsupported streaming operation failures.

The materialized view reflects the correct aggregate after its refresh would demonstrate the separate action Use a materialized view with the desired declarative query, which addresses “A daily dashboard needs a recomputed aggregate over upstream data.” It does not verify the requirement “A stream source is being consumed with an operation that is unsupported incrementally” following Use a materialized view or redesign as a supported incremental transformation.

The pipeline discovers new files and commits them without a daily full scan would demonstrate the separate action Use the Auto Loader `cloudFiles` streaming source in a pipeline dataset, which addresses “A pipeline must ingest a stream from supported cloud files with Auto Loader.” It does not verify the requirement “A stream source is being consumed with an operation that is unsupported incrementally” following Use a materialized view or redesign as a supported incremental transformation.

The alternative Configure suitable pipeline updates and materialized view refresh has a distinct purpose—A materialized view is required to be refreshed by a pipeline schedule rather than on every source event. It would not establish the required outcome (An intermediate dataset should automatically refresh when upstream dependencies change); the necessary verification concerns The pipeline dependency graph includes the upstream table and refreshes in order.

Read the incremental source into a streaming table instead of overwriting a static table is appropriate when “A target needs append-only ingestion rather than destructive daily replacement”; it would be verified by A second update adds new source rows without replacing prior accepted rows. It does not directly satisfy “An intermediate dataset should automatically refresh when upstream dependencies change,” whose relevant acceptance evidence is The pipeline dependency graph includes the upstream table and refreshes in order.

The alternative Add explicit schema/field validation and route the invalid dataset to a controlled failure has a distinct purpose—An upstream contract change makes a required field disappear completely. It would not establish the required outcome (An intermediate dataset should automatically refresh when upstream dependencies change); the necessary verification concerns The pipeline dependency graph includes the upstream table and refreshes in order.

This signal belongs to the adjacent case “A pipeline needs a reused intermediate subquery with no persisted public table,” whose remedy is Refactor the logic into a reusable function or private intermediate dataset as supported. The observed result for the present requirement is The pipeline dependency graph includes the upstream table and refreshes in order.

That observation is a valid indicator for “A target needs append-only ingestion rather than destructive daily replacement” when using Read the incremental source into a streaming table instead of overwriting a static table. The scenario instead tests “An intermediate dataset should automatically refresh when upstream dependencies change”; the relevant result is The pipeline dependency graph includes the upstream table and refreshes in order.

That observation is a valid indicator for “An upstream contract change makes a required field disappear completely” when using Add explicit schema/field validation and route the invalid dataset to a controlled failure. The scenario instead tests “An intermediate dataset should automatically refresh when upstream dependencies change”; the relevant result is The pipeline dependency graph includes the upstream table and refreshes in order.

Define a streaming table over an append-only supported source belongs to the separate case “A streaming table should preserve append-only raw events rather than reaggregate the entire source,” where New rows appear while previous committed rows remain present would be expected. That differs from the condition in this stem: “A target needs append-only ingestion rather than destructive daily replacement.”

Use a materialized view with the desired declarative query belongs to the separate case “A daily dashboard needs a recomputed aggregate over upstream data,” where The materialized view reflects the correct aggregate after its refresh would be expected. That differs from the condition in this stem: “A target needs append-only ingestion rather than destructive daily replacement.”

The alternative Use a supported `@dp.table`-style streaming table definition with the streaming DataFrame has a distinct purpose—A source needs an append-only streaming target defined in Python. It would not establish the required outcome (A target needs append-only ingestion rather than destructive daily replacement); the necessary verification concerns A second update adds new source rows without replacing prior accepted rows.

That observation is a valid indicator for “A pipeline must ingest a stream from supported cloud files with Auto Loader” when using Use the Auto Loader `cloudFiles` streaming source in a pipeline dataset. The scenario instead tests “A target needs append-only ingestion rather than destructive daily replacement”; the relevant result is A second update adds new source rows without replacing prior accepted rows.

This signal belongs to the adjacent case “A streaming table should preserve append-only raw events rather than reaggregate the entire source,” whose remedy is Define a streaming table over an append-only supported source. The observed result for the present requirement is A second update adds new source rows without replacing prior accepted rows.

That observation is a valid indicator for “An intermediate dataset should automatically refresh when upstream dependencies change” when using Declare its streaming table or materialized view with a dependency on the source dataset. The scenario instead tests “A target needs append-only ingestion rather than destructive daily replacement”; the relevant result is A second update adds new source rows without replacing prior accepted rows.