A task orchestrator has been configured to run two hourly tasks. First, an outside system writes Parquet data to a directory mounted at /mnt/raw_orders/. After this data is written, a Databricks job containing the following code is executed:

Assume that the fields customer_id and order_id serve as a composite key to uniquely identify each order, and that the time field indicates when the record was queued in the source system.
If the upstream system is known to occasionally enqueue duplicate entries for a single order hours apart, which statement is correct?

• A. Duplicate records enqueued more than 2 hours apart may be retained and the orders table may contain duplicate records with the same customer_id and order_id.
• B. Duplicate records arriving more than 2 hours apart will be dropped, but duplicates that arrive in the same batch may both be written to the orders table.
• C. The orders table will contain only the most recent 2 hours of records and no duplicates will be present.
• D. The orders table will not contain duplicates, but records arriving more than 2 hours late will be ignored and missing from the table.
• E. All records will be held in the state store for 2 hours before being deduplicated and committed to the orders table.

A facilities-monitoring team is building a near-real-time PowerBI dashboard off the Delta table device_readings:
Columns:
device_id (STRING, unique sensor ID)
event_ts (TIMESTAMP, ingestion timestamp UTC)
temperature_c (DOUBLE, temperature in °C)
Requirement:
For each sensor, generate one row per non-overlapping 5-minute
interval, offset by 2 minutes (e.g., 00:02-00:07, 00:07-00:12, ...).
Each row must include interval start, interval end, and average
temperature in that slice.
Downstream BI tools (e.g., Power BI) must use the interval timestamps
to plot time-series bars.

• A. SELECT device_id,
  date_trunc('minute', event_ts - INTERVAL 2 MINUTES) + INTERVAL 2 MINUTES AS bucket_start, date_trunc('minute', event_ts - INTERVAL 2 MINUTES) + INTERVAL 7 MINUTES AS bucket_end, AVG(temperature_c) AS avg_temp_5m FROM device_readings GROUP BY device_id, date_trunc('minute', event_ts - INTERVAL 2 MINUTES) ORDER BY device_id, bucket_start;
• B. WITH buckets AS (
  SELECT device_id,
  window(event_ts, '5 minutes', '2 minutes', '5 minutes') AS win,
  temperature_c
  FROM device_readings
  )
  SELECT device_id,
  win.start AS bucket_start,
  win.end AS bucket_end,
  AVG(temperature_c) AS avg_temp_5m
  FROM buckets
  GROUP BY device_id, win
  ORDER BY device_id, bucket_start;
• C. SELECT device_id,
  event_ts,
  AVG(temperature_c) OVER (
  PARTITION BY device_id
  ORDER BY event_ts
  RANGE BETWEEN INTERVAL 5 MINUTES PRECEDING AND CURRENT ROW
  ) AS avg_temp_5m
  FROM device_readings
  WINDOW w AS (window(event_ts, '5 minutes', '2 minutes'));
• D. SELECT device_id,
  window.start AS bucket_start,
  window.end AS bucket_end,
  AVG(temperature_c) AS avg_temp_5m
  FROM device_readings
  GROUP BY device_id, window(event_ts, '5 minutes', '5 minutes', '2 minutes') ORDER BY device_id, bucket_start;

An hourly batch job is configured to ingest data files from a cloud object storage container where each batch represent all records produced by the source system in a given hour. The batch job to process these records into the Lakehouse is sufficiently delayed to ensure no late-arriving data is missed. The user_id field represents a unique key for the data, which has the following schema:
user_id BIGINT, username STRING, user_utc STRING, user_region STRING, last_login BIGINT, auto_pay BOOLEAN, last_updated BIGINT New records are all ingested into a table named account_history which maintains a full record of all data in the same schema as the source. The next table in the system is named account_current and is implemented as a Type 1 table representing the most recent value for each unique user_id.
Assuming there are millions of user accounts and tens of thousands of records processed hourly, which implementation can be used to efficiently update the described account_current table as part of each hourly batch job?

• A. Use Auto Loader to subscribe to new files in the account history directory; configure a Structured Streaminq trigger once job to batch update newly detected files into the account current table.
• B. Overwrite the account current table with each batch using the results of a query against the account history table grouping by user id and filtering for the max value of last updated.
• C. Filter records in account history using the last updated field and the most recent hour processed, making sure to deduplicate on username; write a merge statement to update or insert the most recent value for each username.
• D. Filter records in account history using the last updated field and the most recent hour processed, as well as the max last iogin by user id write a merge statement to update or insert the most recent value for each user id.
• E. Use Delta Lake version history to get the difference between the latest version of account history and one version prior, then write these records to account current.

Each configuration below is identical to the extent that each cluster has 400 GB total of RAM, 160 total cores and only one Executor per VM.
Given a job with at least one wide transformation, which of the following cluster configurations will result in maximum performance?

• A. Total VMs: 8
  50 GB per Executor
  20 Cores / Executor
• B. Total VMs: 2
  200 GB per Executor
  80 Cores / Executor
• C. Total VMs: 1
  400 GB per Executor
  160 Cores / Executor
• D. Total VMs: 4
  100 GB per Executor
  40 Cores/Executor