Exam Bundle

New unexpected attributes appear in the rescued data payload would demonstrate the separate action Use Auto Loader `rescue` schema evolution mode with a rescued data column, which addresses “Unexpected fields should be retained for inspection but not added to the target schema.” It does not verify the requirement “An upstream contract change makes a required field disappear completely” following Add explicit schema/field validation and route the invalid dataset to a controlled failure.

This signal belongs to the adjacent case “A source numeric type widens within supported compatibility boundaries,” whose remedy is Use supported schema/type widening handling rather than forcing lossy casts. The observed result for the present requirement is The job fails with a missing-required-field signal before publishing incorrect output.

A restart after a new column update recognizes the evolved schema pertains to a different control (Configure appropriate Auto Loader schema evolution and persisted schema location) and a different need (New optional JSON fields should be captured without discarding previously known columns). It cannot establish that Add explicit schema/field validation and route the invalid dataset to a controlled failure met the stated goal.

Prefer the built-in expression over a custom Python UDF is appropriate when “A built-in Spark SQL function already implements the required standard calculation”; it would be verified by The explain plan avoids an unnecessary Python execution operator. It does not directly satisfy “Analysts need a reusable scalar currency normalization expression across several queries,” whose relevant acceptance evidence is Authorized SQL users call the same function and get matching normalized values.

Create a supported SQL table function returning the defined relation belongs to the separate case “A table-valued transformation must be reusable with an input parameter,” where The function call returns the expected rows and columns for sample input would be expected. That differs from the condition in this stem: “Analysts need a reusable scalar currency normalization expression across several queries.”

Revoke its EXECUTE privilege from unauthorized principals belongs to the separate case “A function should not execute for teams that lack approval to use it,” where Unauthorized calls fail permission checking while authorized calls succeed would be expected. That differs from the condition in this stem: “Analysts need a reusable scalar currency normalization expression across several queries.”

That observation is a valid indicator for “A table-valued transformation must be reusable with an input parameter” when using Create a supported SQL table function returning the defined relation. The scenario instead tests “Analysts need a reusable scalar currency normalization expression across several queries”; the relevant result is Authorized SQL users call the same function and get matching normalized values.

The explain plan avoids an unnecessary Python execution operator would demonstrate the separate action Prefer the built-in expression over a custom Python UDF, which addresses “A built-in Spark SQL function already implements the required standard calculation.” It does not verify the requirement “Analysts need a reusable scalar currency normalization expression across several queries” following Create a Unity Catalog SQL scalar function with explicit parameter and return types.

The tested null and nonnull cases satisfy the documented contract pertains to a different control (Update the function body with explicit null behavior and add null-input tests) and a different need (A SQL function produces the wrong result for null arguments under business rules). It cannot establish that Create a Unity Catalog SQL scalar function with explicit parameter and return types met the stated goal.

The alternative Update the function body with explicit null behavior and add null-input tests has a distinct purpose—A SQL function produces the wrong result for null arguments under business rules. It would not establish the required outcome (A table-valued transformation must be reusable with an input parameter); the necessary verification concerns The function call returns the expected rows and columns for sample input.

The alternative Revoke its EXECUTE privilege from unauthorized principals has a distinct purpose—A function should not execute for teams that lack approval to use it. It would not establish the required outcome (A table-valued transformation must be reusable with an input parameter); the necessary verification concerns The function call returns the expected rows and columns for sample input.

Prefer the built-in expression over a custom Python UDF belongs to the separate case “A built-in Spark SQL function already implements the required standard calculation,” where The explain plan avoids an unnecessary Python execution operator would be expected. That differs from the condition in this stem: “A table-valued transformation must be reusable with an input parameter.”

That observation is a valid indicator for “A function should not execute for teams that lack approval to use it” when using Revoke its EXECUTE privilege from unauthorized principals. The scenario instead tests “A table-valued transformation must be reusable with an input parameter”; the relevant result is The function call returns the expected rows and columns for sample input.

This signal belongs to the adjacent case “Analysts need a reusable scalar currency normalization expression across several queries,” whose remedy is Create a Unity Catalog SQL scalar function with explicit parameter and return types. The observed result for the present requirement is The function call returns the expected rows and columns for sample input.

The explain plan avoids an unnecessary Python execution operator pertains to a different control (Prefer the built-in expression over a custom Python UDF) and a different need (A built-in Spark SQL function already implements the required standard calculation). It cannot establish that Create a supported SQL table function returning the defined relation met the stated goal.

This action solves a different issue: “Analysts need a reusable scalar currency normalization expression across several queries.” Its normal signal is Authorized SQL users call the same function and get matching normalized values. Here the requested behavior is “A function should not execute for teams that lack approval to use it,” so that signal is not sufficient.

Update the function body with explicit null behavior and add null-input tests belongs to the separate case “A SQL function produces the wrong result for null arguments under business rules,” where The tested null and nonnull cases satisfy the documented contract would be expected. That differs from the condition in this stem: “A function should not execute for teams that lack approval to use it.”

Prefer the built-in expression over a custom Python UDF is appropriate when “A built-in Spark SQL function already implements the required standard calculation”; it would be verified by The explain plan avoids an unnecessary Python execution operator. It does not directly satisfy “A function should not execute for teams that lack approval to use it,” whose relevant acceptance evidence is Unauthorized calls fail permission checking while authorized calls succeed.

The tested null and nonnull cases satisfy the documented contract pertains to a different control (Update the function body with explicit null behavior and add null-input tests) and a different need (A SQL function produces the wrong result for null arguments under business rules). It cannot establish that Revoke its EXECUTE privilege from unauthorized principals met the stated goal.

The function call returns the expected rows and columns for sample input would demonstrate the separate action Create a supported SQL table function returning the defined relation, which addresses “A table-valued transformation must be reusable with an input parameter.” It does not verify the requirement “A function should not execute for teams that lack approval to use it” following Revoke its EXECUTE privilege from unauthorized principals.

The explain plan avoids an unnecessary Python execution operator would demonstrate the separate action Prefer the built-in expression over a custom Python UDF, which addresses “A built-in Spark SQL function already implements the required standard calculation.” It does not verify the requirement “A function should not execute for teams that lack approval to use it” following Revoke its EXECUTE privilege from unauthorized principals.

Create a supported SQL table function returning the defined relation is appropriate when “A table-valued transformation must be reusable with an input parameter”; it would be verified by The function call returns the expected rows and columns for sample input. It does not directly satisfy “A built-in Spark SQL function already implements the required standard calculation,” whose relevant acceptance evidence is The explain plan avoids an unnecessary Python execution operator.

Update the function body with explicit null behavior and add null-input tests belongs to the separate case “A SQL function produces the wrong result for null arguments under business rules,” where The tested null and nonnull cases satisfy the documented contract would be expected. That differs from the condition in this stem: “A built-in Spark SQL function already implements the required standard calculation.”

Create a Unity Catalog SQL scalar function with explicit parameter and return types is appropriate when “Analysts need a reusable scalar currency normalization expression across several queries”; it would be verified by Authorized SQL users call the same function and get matching normalized values. It does not directly satisfy “A built-in Spark SQL function already implements the required standard calculation,” whose relevant acceptance evidence is The explain plan avoids an unnecessary Python execution operator.

The function call returns the expected rows and columns for sample input pertains to a different control (Create a supported SQL table function returning the defined relation) and a different need (A table-valued transformation must be reusable with an input parameter). It cannot establish that Prefer the built-in expression over a custom Python UDF met the stated goal.

That observation is a valid indicator for “Analysts need a reusable scalar currency normalization expression across several queries” when using Create a Unity Catalog SQL scalar function with explicit parameter and return types. The scenario instead tests “A built-in Spark SQL function already implements the required standard calculation”; the relevant result is The explain plan avoids an unnecessary Python execution operator.

Unauthorized calls fail permission checking while authorized calls succeed would demonstrate the separate action Revoke its EXECUTE privilege from unauthorized principals, which addresses “A function should not execute for teams that lack approval to use it.” It does not verify the requirement “A built-in Spark SQL function already implements the required standard calculation” following Prefer the built-in expression over a custom Python UDF.

The alternative Prefer the built-in expression over a custom Python UDF has a distinct purpose—A built-in Spark SQL function already implements the required standard calculation. It would not establish the required outcome (A SQL function produces the wrong result for null arguments under business rules); the necessary verification concerns The tested null and nonnull cases satisfy the documented contract.

Create a Unity Catalog SQL scalar function with explicit parameter and return types is appropriate when “Analysts need a reusable scalar currency normalization expression across several queries”; it would be verified by Authorized SQL users call the same function and get matching normalized values. It does not directly satisfy “A SQL function produces the wrong result for null arguments under business rules,” whose relevant acceptance evidence is The tested null and nonnull cases satisfy the documented contract.

Revoke its EXECUTE privilege from unauthorized principals belongs to the separate case “A function should not execute for teams that lack approval to use it,” where Unauthorized calls fail permission checking while authorized calls succeed would be expected. That differs from the condition in this stem: “A SQL function produces the wrong result for null arguments under business rules.”

This signal belongs to the adjacent case “A function should not execute for teams that lack approval to use it,” whose remedy is Revoke its EXECUTE privilege from unauthorized principals. The observed result for the present requirement is The tested null and nonnull cases satisfy the documented contract.

The explain plan avoids an unnecessary Python execution operator pertains to a different control (Prefer the built-in expression over a custom Python UDF) and a different need (A built-in Spark SQL function already implements the required standard calculation). It cannot establish that Update the function body with explicit null behavior and add null-input tests met the stated goal.

That observation is a valid indicator for “Analysts need a reusable scalar currency normalization expression across several queries” when using Create a Unity Catalog SQL scalar function with explicit parameter and return types. The scenario instead tests “A SQL function produces the wrong result for null arguments under business rules”; the relevant result is The tested null and nonnull cases satisfy the documented contract.