Exam Bundle

Only keys absent from the authorized snapshot scope are removed would demonstrate the separate action Apply a scoped `WHEN NOT MATCHED BY SOURCE THEN DELETE` clause, which addresses “The full snapshot is authoritative and stale target keys must be purged.” It does not verify the requirement “A retried merge must not produce duplicate logical business records” following Use deterministic stable keys and idempotent matched/not-matched logic.

That observation is a valid indicator for “Rows marked deleted should be removed only when the incoming event is newer” when using Use a sequenced matched-delete predicate in MERGE. The scenario instead tests “A retried merge must not produce duplicate logical business records”; the relevant result is Re-execution leaves one current target row per key.

One committed transaction applies the intended upsert would demonstrate the separate action Use Delta `MERGE INTO` with matched update and not-matched insert, which addresses “Matched keys should update and unseen keys should be inserted atomically.” It does not verify the requirement “A retried merge must not produce duplicate logical business records” following Use deterministic stable keys and idempotent matched/not-matched logic.

The alternative Use supported variant-path extraction or accessor expressions has a distinct purpose—An analyst needs to read a nested customer identifier from a VARIANT value. It would not establish the required outcome (An arbitrary JSON document should retain dynamic structure without forcing a fixed schema); the necessary verification concerns Queries can access new nested attributes without changing a rigid schema.

Use supported variant explosion or array expansion functions is appropriate when “A variable list of event objects must be expanded to one row per contained item”; it would be verified by Each array element becomes its own row with parent event association. It does not directly satisfy “An arbitrary JSON document should retain dynamic structure without forcing a fixed schema,” whose relevant acceptance evidence is Queries can access new nested attributes without changing a rigid schema.

Use null-safe path extraction with explicit default handling belongs to the separate case “An optional JSON property is missing and the query must not crash,” where The missing attribute yields the intended null or default value would be expected. That differs from the condition in this stem: “An arbitrary JSON document should retain dynamic structure without forcing a fixed schema.”

Subsequent path queries return correctly typed or cast results would demonstrate the separate action Use a supported `parse_json`-style expression for VARIANT, which addresses “Raw JSON strings should be parsed as structured variant values before querying fields.” It does not verify the requirement “An arbitrary JSON document should retain dynamic structure without forcing a fixed schema” following Store it in the supported Databricks VARIANT data type.

Each array element becomes its own row with parent event association pertains to a different control (Use supported variant explosion or array expansion functions) and a different need (A variable list of event objects must be expanded to one row per contained item). It cannot establish that Store it in the supported Databricks VARIANT data type met the stated goal.

The extracted scalar equals the identifier in the JSON payload pertains to a different control (Use supported variant-path extraction or accessor expressions) and a different need (An analyst needs to read a nested customer identifier from a VARIANT value). It cannot establish that Store it in the supported Databricks VARIANT data type met the stated goal.

This action solves a different issue: “An optional JSON property is missing and the query must not crash.” Its normal signal is The missing attribute yields the intended null or default value. Here the requested behavior is “An analyst needs to read a nested customer identifier from a VARIANT value,” so that signal is not sufficient.

This action solves a different issue: “An arbitrary JSON document should retain dynamic structure without forcing a fixed schema.” Its normal signal is Queries can access new nested attributes without changing a rigid schema. Here the requested behavior is “An analyst needs to read a nested customer identifier from a VARIANT value,” so that signal is not sufficient.

Use a supported `parse_json`-style expression for VARIANT is appropriate when “Raw JSON strings should be parsed as structured variant values before querying fields”; it would be verified by Subsequent path queries return correctly typed or cast results. It does not directly satisfy “An analyst needs to read a nested customer identifier from a VARIANT value,” whose relevant acceptance evidence is The extracted scalar equals the identifier in the JSON payload.

Each array element becomes its own row with parent event association pertains to a different control (Use supported variant explosion or array expansion functions) and a different need (A variable list of event objects must be expanded to one row per contained item). It cannot establish that Use supported variant-path extraction or accessor expressions met the stated goal.

Subsequent path queries return correctly typed or cast results would demonstrate the separate action Use a supported `parse_json`-style expression for VARIANT, which addresses “Raw JSON strings should be parsed as structured variant values before querying fields.” It does not verify the requirement “An analyst needs to read a nested customer identifier from a VARIANT value” following Use supported variant-path extraction or accessor expressions.

Queries can access new nested attributes without changing a rigid schema pertains to a different control (Store it in the supported Databricks VARIANT data type) and a different need (An arbitrary JSON document should retain dynamic structure without forcing a fixed schema). It cannot establish that Use supported variant-path extraction or accessor expressions met the stated goal.

Store it in the supported Databricks VARIANT data type belongs to the separate case “An arbitrary JSON document should retain dynamic structure without forcing a fixed schema,” where Queries can access new nested attributes without changing a rigid schema would be expected. That differs from the condition in this stem: “A variable list of event objects must be expanded to one row per contained item.”

Use a supported `parse_json`-style expression for VARIANT is appropriate when “Raw JSON strings should be parsed as structured variant values before querying fields”; it would be verified by Subsequent path queries return correctly typed or cast results. It does not directly satisfy “A variable list of event objects must be expanded to one row per contained item,” whose relevant acceptance evidence is Each array element becomes its own row with parent event association.

Use null-safe path extraction with explicit default handling belongs to the separate case “An optional JSON property is missing and the query must not crash,” where The missing attribute yields the intended null or default value would be expected. That differs from the condition in this stem: “A variable list of event objects must be expanded to one row per contained item.”

This signal belongs to the adjacent case “An optional JSON property is missing and the query must not crash,” whose remedy is Use null-safe path extraction with explicit default handling. The observed result for the present requirement is Each array element becomes its own row with parent event association.

Queries can access new nested attributes without changing a rigid schema pertains to a different control (Store it in the supported Databricks VARIANT data type) and a different need (An arbitrary JSON document should retain dynamic structure without forcing a fixed schema). It cannot establish that Use supported variant explosion or array expansion functions met the stated goal.

This signal belongs to the adjacent case “Raw JSON strings should be parsed as structured variant values before querying fields,” whose remedy is Use a supported `parse_json`-style expression for VARIANT. The observed result for the present requirement is Each array element becomes its own row with parent event association.

The alternative Store it in the supported Databricks VARIANT data type has a distinct purpose—An arbitrary JSON document should retain dynamic structure without forcing a fixed schema. It would not establish the required outcome (An optional JSON property is missing and the query must not crash); the necessary verification concerns The missing attribute yields the intended null or default value.

Use a supported `parse_json`-style expression for VARIANT is appropriate when “Raw JSON strings should be parsed as structured variant values before querying fields”; it would be verified by Subsequent path queries return correctly typed or cast results. It does not directly satisfy “An optional JSON property is missing and the query must not crash,” whose relevant acceptance evidence is The missing attribute yields the intended null or default value.

Use supported variant-path extraction or accessor expressions is appropriate when “An analyst needs to read a nested customer identifier from a VARIANT value”; it would be verified by The extracted scalar equals the identifier in the JSON payload. It does not directly satisfy “An optional JSON property is missing and the query must not crash,” whose relevant acceptance evidence is The missing attribute yields the intended null or default value.

That observation is a valid indicator for “An analyst needs to read a nested customer identifier from a VARIANT value” when using Use supported variant-path extraction or accessor expressions. The scenario instead tests “An optional JSON property is missing and the query must not crash”; the relevant result is The missing attribute yields the intended null or default value.

That observation is a valid indicator for “Raw JSON strings should be parsed as structured variant values before querying fields” when using Use a supported `parse_json`-style expression for VARIANT. The scenario instead tests “An optional JSON property is missing and the query must not crash”; the relevant result is The missing attribute yields the intended null or default value.

Each array element becomes its own row with parent event association pertains to a different control (Use supported variant explosion or array expansion functions) and a different need (A variable list of event objects must be expanded to one row per contained item). It cannot establish that Use null-safe path extraction with explicit default handling met the stated goal.

The alternative Use null-safe path extraction with explicit default handling has a distinct purpose—An optional JSON property is missing and the query must not crash. It would not establish the required outcome (Raw JSON strings should be parsed as structured variant values before querying fields); the necessary verification concerns Subsequent path queries return correctly typed or cast results.

Use supported variant explosion or array expansion functions belongs to the separate case “A variable list of event objects must be expanded to one row per contained item,” where Each array element becomes its own row with parent event association would be expected. That differs from the condition in this stem: “Raw JSON strings should be parsed as structured variant values before querying fields.”

Store it in the supported Databricks VARIANT data type belongs to the separate case “An arbitrary JSON document should retain dynamic structure without forcing a fixed schema,” where Queries can access new nested attributes without changing a rigid schema would be expected. That differs from the condition in this stem: “Raw JSON strings should be parsed as structured variant values before querying fields.”

That observation is a valid indicator for “An optional JSON property is missing and the query must not crash” when using Use null-safe path extraction with explicit default handling. The scenario instead tests “Raw JSON strings should be parsed as structured variant values before querying fields”; the relevant result is Subsequent path queries return correctly typed or cast results.

This signal belongs to the adjacent case “A variable list of event objects must be expanded to one row per contained item,” whose remedy is Use supported variant explosion or array expansion functions. The observed result for the present requirement is Subsequent path queries return correctly typed or cast results.

This signal belongs to the adjacent case “An analyst needs to read a nested customer identifier from a VARIANT value,” whose remedy is Use supported variant-path extraction or accessor expressions. The observed result for the present requirement is Subsequent path queries return correctly typed or cast results.