Get real Certified-Data-Engineer-Professional exam questions for better preparation

A data engineer is configuring a Databricks Asset Bundle to deploy a job with granular permissions.
The requirements are:
- Grant the data-engineers group CAN_MANAGE access to the job.
- Ensure the auditors' group can view the job but not modify/run it.
- Avoid granting unintended permissions to other users/groups.
How should the data engineer deploy the job while meeting the requirements?

• A. permissions:
  - group_name: data-engineers
  level: CAN_MANAGE
  - group_name: auditors
  level: CAN_VIEW
  resources:
  jobs:
  my-job:
  name: data-pipeline
  tasks: [...]
  job_clusters: [...]
• B. resources:
  jobs:
  my-job:
  name: data-pipeline
  tasks: [...]
  job: [...]
  permissions:
  - group_name: data-engineers
  level: CAN_MANAGE
  permissions:
  - group_name: auditors
  level: CAN_VIEW
• C. resources:
  jobs:
  my-job:
  name: data-pipeline
  tasks: [...]
  job_clusters: [...]
  permissions:
  - group_name: data-engineers
  level: CAN_MANAGE
  - group_name: auditors
  level: CAN_VIEW
  - group_name: admin-team
  level: IS_OWNER
• D. resources:
  jobs:
  my-job:
  name: data-pipeline
  tasks: [...]
  job_clusters: [...]
  permissions:
  - group_name: data-engineers
  level: CAN_MANAGE
  - group_name: auditors
  level: CAN_VIEW

An analytics team wants to run a short-term experiment in Databricks SQL on the customer transactions Delta table (about 20 billion records) created by the data engineering team. Which strategy should the data engineering team use to ensure minimal downtime and no impact on the ongoing ETL processes?

• A. Create a new table for the analytics team using a CTAS statement.
• B. Give the analytics team direct access to the production table.
• C. Deep clone the table for the analytics team.
• D. Shallow clone the table for the analytics team.

A data engineer needs to implement column masking for a sensitive column in a Unity Catalog- managed table. The masking logic must dynamically check if users belong to specific groups defined in a separate table (group_access) that maps groups to allowed departments. Which approach should the engineer use to efficiently enforce this requirement?

• A. Apply a column mask that references the group_access mapping table in its UDF.
• B. Create a view without selecting the sensitive column.
• C. Use a row filter to restrict access based on the user's group.
• D. Create a UDF that hardcodes allowed groups and apply it as a column mask.

A nightly batch job is configured to ingest all data files from a cloud object storage container where records are stored in a nested directory structure YYYY/MM/DD. The data for each date represents all records that were processed by the source system on that date, noting that some records may be delayed as they await moderator approval. Each entry represents a user review of a product and has the following schema:
user_id STRING, review_id BIGINT, product_id BIGINT, review_timestamp TIMESTAMP, review_text STRING The ingestion job is configured to append all data for the previous date to a target table reviews_raw with an identical schema to the source system. The next step in the pipeline is a batch write to propagate all new records inserted into reviews_raw to a table where data is fully deduplicated, validated, and enriched.
Which solution minimizes the compute costs to propagate this batch of data?

• A. Filter all records in the reviews_raw table based on the review_timestamp; batch append those records produced in the last 48 hours.
• B. Perform a batch read on the reviews_raw table and perform an insert-only merge using the natural composite key user_id, review_id, product_id, review_timestamp.
• C. Configure a Structured Streaming read against the reviews_raw table using the trigger once execution mode to process new records as a batch job.
• D. Use Delta Lake version history to get the difference between the latest version of reviews_raw and one version prior, then write these records to the next table.
• E. Reprocess all records in reviews_raw and overwrite the next table in the pipeline.

A data engineer wants to join a stream of advertisement impressions (when an ad was shown) with another stream of user clicks on advertisements to correlate when impressions led to monetizable clicks.
In the code below, Impressions is a streaming DataFrame with a watermark ("event_time", "10 minutes")

The data engineer notices the query slowing down significantly.
Which solution would improve the performance?

• A. Joining on event time constraint: clickTime == impressionTime using a leftOuter join
• B. Joining on event time constraint: clickTime + 3 hours < impressionTime - 2 hours
• C. Joining on event time constraint: clickTime >= impressionTime - interval 3 hours and removing watermarks
• D. Joining on event time constraint: clickTime >= impressionTime AND clickTime <= impressionTime interval 1 hour