A data engineering team needs to create a SQL Alert that monitors data quality across multiple columns in their customer table. They want to trigger an alert when both the percentage of customers with missing email addresses exceeds 15% AND the percentage of customers with invalid phone number formats exceeds 10%. Which SQL query pattern is appropriate for implementing this multi-column alert condition?

• A. SELECT CASE WHEN email_null_pct >15 AND phone_invalid_pct> 10 THEN 1 ELSE 0 END FROM (SELECT (COUNT (CASE WHEN email IS NULL THEN 1 END) * 100.0 / COUNT (*)) as phone_invalid_pct FROM customers) metrics
• B. SELECT COUNT (*) FROM customers WHERE email IS NULL OR phone_format_invalid = true
• C. SELECT email_null_pct, phone_invalid_pct FROM (SELECT (COUNT(CASE WHEN email IS NULL THEN 1 END) *
  100.0/COUNT (*)) as email_null_pct, (COUNT(CASE WHEN phone NOT RLIKE 'ˆ[0-9-+()\\s]+$' THEN 1 END)*
  100.0/COUNT (*)) as phone_invalid_pct FROM customers)
• D. SELECT email, phone FROM customers WHERE email IS NULL AND phone NOT RLIKE 'ˆ[0-9-
  +()\\s]+$'

A data engineer is using Lakeflow Declarative Pipelines Expectations feature to track the data quality of their incoming sensor data. Periodically, sensors send bad readings that are out of range, and they are currently flagging those rows with a warning and writing them to the silver table along with the good data. They've been given a new requirement ?the bad rows need to be quarantined in a separate quarantine table and no longer included in the silver table.
This is the existing code for their silver table:
@dlt.table
@dlt.expect("valid_sensor_reading", "reading < 120")
def silver_sensor_readings():
return spark.readStream.table("bronze_sensor_readings")
What code will satisfy the requirements?

• A. @dlt.table
  @dlt.expect_or_drop("valid_sensor_reading", "reading < 120")
  def silver_sensor_readings():
  return spark.readStream.table("bronze_sensor_readings")
  @dlt.table
  @dlt.expect_or_drop("invalid_sensor_reading", "reading >= 120")
  def quarantine_sensor_readings():
  return spark.readStream.table("bronze_sensor_readings")
• B. @dlt.table
  @dlt.expect_or_drop("valid_sensor_reading", "reading < 120")
  def silver_sensor_readings():
  return spark.readStream.table("bronze_sensor_readings")
  @dlt.table
  @dlt.expect("invalid_sensor_reading", "reading >= 120")
  def quarantine_sensor_readings():
  return spark.readStream.table("bronze_sensor_readings")
• C. @dlt.table
  @dlt.expect("valid_sensor_reading", "reading < 120")
  def silver_sensor_readings():
  return spark.readStream.table("bronze_sensor_readings")
  @dlt.table
  @dlt.expect("invalid_sensor_reading", "reading >= 120")
  def quarantine_sensor_readings():
  return spark.readStream.table("bronze_sensor_readings")
• D. @dlt.table
  @dlt.expect_or_drop("valid_sensor_reading", "reading < 120")
  def silver_sensor_readings():
  return spark.readStream.table("bronze_sensor_readings")
  @dlt.table
  @dlt.expect("invalid_sensor_reading", "reading < 120")
  def quarantine_sensor_readings():
  return spark.readStream.table("bronze_sensor_readings")

A data engineer has created a transactions Delta table on Databricks that should be used by the analytics team. The analytics team wants to use the table with another tool that requires Apache Iceberg format. What should the data engineer do?

• A. Create an Iceberg copy of the transactions Delta table which can be used by the analytics team.
• B. Require the analytics team to use a tool that supports Delta table.
• C. Convert the transactions Delta table to Iceberg and enable uniform so that the table can be read as a Delta table.
• D. Enable uniform on the transactions table to 'iceberg' so that the table can be read as an Iceberg table.

A data engineer needs to capture pipeline settings from an existing in the workspace, and use them to create and version a JSON file to create a new pipeline. Which command should the data engineer enter in a web terminal configured with the Databricks CLI?

• A. Stop the existing pipeline; use the returned settings in a reset command
• B. Use list pipelines to get the specs for all pipelines; get the pipeline spec from the return results parse and use this to create a pipeline
• C. Use the alone command to create a copy of an existing pipeline; use the get JSON command to get the pipeline definition; save this to git
• D. Use the get command to capture the settings for the existing pipeline; remove the pipeline_id and rename the pipeline; use this in a create command

A data ingestion task requires a one-TB JSON dataset to be written out to Parquet with a target part-file size of 512 MB. Because Parquet is being used instead of Delta Lake, built-in file-sizing features such as Auto-Optimize & Auto-Compaction cannot be used.
Which strategy will yield the best performance without shuffling data?

• A. Set spark.sql.adaptive.advisoryPartitionSizeInBytes to 512 MB bytes, ingest the data, execute the narrow transformations, coalesce to 2,048 partitions (1TB*1024*1024/512), and then write to parquet.
• B. Set spark.sql.shuffle.partitions to 2,048 partitions (1TB*1024*1024/512), ingest the data, execute the narrow transformations, optimize the data by sorting it (which automatically repartitions the data), and then write to parquet.
• C. Set spark.sql.files.maxPartitionBytes to 512 MB, ingest the data, execute the narrow transformations, and then write to parquet.
• D. Set spark.sql.shuffle.partitions to 512, ingest the data, execute the narrow transformations, and then write to parquet.
• E. Ingest the data, execute the narrow transformations, repartition to 2,048 partitions (1TB*
  1024*1024/512), and then write to parquet.