[Full-Version] 2026 New Certified-Data-Engineer-Professional Actual Exam Dumps, Databricks Practice Test [Q137-Q161]

11Oct 2026 by admin No Comments

Rate this post

[Full-Version] 2026 New Certified-Data-Engineer-Professional Actual Exam Dumps, Databricks Practice Test

Study HIGH Quality Certified-Data-Engineer-Professional Free Study Guides and Exams Tutorials

Databricks Certified-Data-Engineer-Professional Exam Syllabus Topics:

Section	Objectives
Topic 1: Data Transformation, Cleansing, and Quality	– Data Quality 1. Apply data quality controls using Lakeflow Spark Declarative Pipelines or Auto Loader 2. Develop data quarantining processes for invalid data – Advanced Data Transformation 1. Write efficient Spark SQL and PySpark transformations 2. Apply window functions, joins, and aggregations to large datasets
Topic 2: Debugging and Deploying	– Deploying CI/CD 1. Build and deploy Databricks resources using Databricks Asset Bundles 2. Integrate Git-based CI/CD workflows using Databricks Git Folders – Debugging and Troubleshooting 1. Use Lakeflow Spark Declarative Pipelines event logs and Spark UI for debugging 2. Analyze errors and remediate failed job runs 3. Use Spark UI, cluster logs, system tables, and query profiles for diagnostics
Topic 3: Developing Code for Data Processing using Python and SQL	– Using Python and Tools for Development 1. Develop User-Defined Functions using Pandas/Python UDFs 2. Design and implement scalable Python project structures optimized for Databricks Asset Bundles 3. Manage and troubleshoot third-party library installations and dependencies – Building and Testing ETL Pipelines 1. Use control flow operators in pipeline components 2. Build production-ready batch and streaming pipelines using Lakeflow Spark Declarative Pipelines and Auto Loader 3. Create and automate ETL workloads using Jobs through UI, APIs, and CLI 4. Compare Spark Structured Streaming and Lakeflow Spark Declarative Pipelines 5. Develop unit and integration tests for data processing code 6. Use APPLY CHANGES APIs for change data capture 7. Compare streaming tables and materialized views 8. Configure environments, dependencies, memory, and retry behavior
Topic 4: Data Modelling	– Dimensional Modelling 1. Design dimensional models for analytical workloads – Scalable Data Models 1. Understand Liquid Clustering versus partitioning and Z-Ordering 2. Design and implement scalable data models using Delta Lake 3. Optimize data layout using Liquid Clustering
Topic 5: Data Governance	– Unity Catalog Permissions 1. Understand the Unity Catalog permission inheritance model – Metadata and Discoverability 1. Create and maintain descriptions and metadata for enterprise data
Topic 6: Ensuring Data Security and Compliance	– Data Security 1. Use ACLs to secure workspace objects and enforce least privilege 2. Apply anonymization and pseudonymization techniques 3. Use row filters and column masks for sensitive data – Compliance 1. Implement pipelines that detect and mask personally identifiable information 2. Develop data purging solutions according to data retention policies
Topic 7: Data Sharing and Federation	– Delta Sharing 1. Share live Lakehouse data with external computing platforms 2. Configure Databricks-to-Databricks Sharing 3. Configure sharing with external platforms using the open sharing protocol – Lakehouse Federation 1. Configure Lakehouse Federation with appropriate governance
Topic 8: Data Ingestion & Acquisition	– Design and implement data ingestion pipelines 1. Ingest data from message buses and cloud storage 2. Build append-only pipelines for batch and streaming data using Delta 3. Ingest Delta Lake, Parquet, ORC, Avro, JSON, CSV, XML, Text, and Binary data
Topic 9: Cost & Performance Optimisation	– Query Performance 1. Identify inefficient joins and excessive data shuffling 2. Use Query Profile to identify performance bottlenecks – Cost Optimization 1. Understand how Unity Catalog managed tables reduce operational overhead – Delta Optimization 1. Use Change Data Feed to address streaming table limitations and improve latency 2. Understand deletion vectors and liquid clustering 3. Apply data skipping and file pruning techniques
Topic 10: Monitoring and Alerting	– Monitoring 1. Use Query Profiler and Spark UI to monitor workloads 2. Use system tables for resource, cost, audit, and workload monitoring 3. Use Databricks REST APIs and CLI for monitoring jobs and pipelines 4. Use Lakeflow Spark Declarative Pipelines event logs for monitoring – Alerting 1. Configure Lakeflow Jobs notifications for job status and performance issues 2. Use SQL Alerts for data quality monitoring

NEW QUESTION 137
A data engineer is building a Lakeflow Declarative Pipelines pipeline to process healthcare claims data. A metadata JSON file defines data quality rules for multiple tables, including:
{
“claims”: [
{“name”: “valid_patient_id”, “constraint”: “patient_id IS NOT NULL”},
{“name”: “non_negative_amount”, “constraint”: “claim_amount >= 0”}
]
}
The pipeline must dynamically apply these rules to the claims table without hardcoding the rules.
How should the data engineer achieve this?

Load the JSON metadata, loop through its entries, and apply expectations using dlt.expect_all.

Invoke an external API to validate records against the metadata rules.

Reference each expectation with @dlt.expect decorators in the table declaration.

Use a SQL CONSTRAINT block referencing the JSON file path.

NEW QUESTION 138
A Databricks SQL dashboard has been configured to monitor the total number of records present in a collection of Delta Lake tables using the following query pattern:
SELECT COUNT (*) FROM table
Which of the following describes how results are generated each time the dashboard is updated?

The total count of rows is calculated by scanning all data files

The total count of rows will be returned from cached results unless REFRESH is run

The total count of records is calculated from the Delta transaction logs

The total count of records is calculated from the parquet file metadata

The total count of records is calculated from the Hive metastore

NEW QUESTION 139
A data engineer is using Lakeflow Declarative Pipeline to propagate row deletions from a source bronze table (user_bronze) to a target silver table (user_silver). The engineer wants deletions in user_bronze to automatically delete corresponding rows in user_silver during pipeline execution.
Which configuration ensures deletions in the bronze table are propagated to the silver table?

Use apply_changes without CDF and filter rows where _soft_deleted is true.

Enable Change Data Feed (CDF) on user_bronze, read its CDF stream, and use apply_changes() with apply_as_deletes=True for user_silver.

Enable CDF on user_silver, read its transaction log, and use MERGE to sync deletions.

Configure VACUUM on user_bronze to delete files, then rebuild user_silver from scratch.

NEW QUESTION 140
A junior data engineer has configured a workload that posts the following JSON to the Databricks REST API endpoint 2.0/jobs/create.

Assuming that all configurations and referenced resources are available, which statement describes the result of executing this workload three times?

Three new jobs named “Ingest new data” will be defined in the workspace, and they will each run once daily.

The logic defined in the referenced notebook will be executed three times on new clusters with the configurations of the provided cluster ID.

Three new jobs named “Ingest new data” will be defined in the workspace, but no jobs will be executed.

One new job named “Ingest new data” will be defined in the workspace, but it will not be executed.

The logic defined in the referenced notebook will be executed three times on the referenced existing all purpose cluster.

NEW QUESTION 141
A company has a task management system that tracks the most recent status of tasks. The system takes task events as input and processes events in near real-time using Lakeflow Declarative Pipelines. A new task event is ingested into the system when a task is created or the task status is changed. Lakeflow Declarative Pipelines provides a streaming table (tasks_status) for BI users to query.
The table represents the latest status of all tasks and includes 5 columns:
task_id (unique for each task)
task_name
task_owner
task_status
task_event_time
The table enables three properties: deletion vectors, row tracking, and change data feed (CDF).
A data engineer is asked to create a new Lakeflow Declarative Pipeline to enrich the tasks_status table in near real-time by adding one additional column representing task_owner’s department, which can be looked up from a static dimension table (employee).
How should this enrichment be implemented?

Create a new Lakeflow Declarative Pipeline: use the readStream() function to read tasks_status table; enrich with the employee table; store the result in a new streaming table.

Create a new Lakeflow Declarative Pipeline: use readStream() function with option readChangeFeed to read tasks_status table CDF; enrich with the employee table; create a new streaming table as the result table and use apply_changes() function to process the changes from the enriched CDF.

Create a new Lakeflow Declarative Pipeline: use the read() function to read tasks_status table; enrich with employee table; store the result in a materialized view.

Create a new Lakeflow Declarative Pipeline: use the readStream() function with the option skipChangeCommits to read the tasks_status table; enrich with the employee table; store the result in a new streaming table.

NEW QUESTION 142
A user wants to use DLT expectations to validate that a derived table report contains all records from the source, included in the table validation_copy.
The user attempts and fails to accomplish this by adding an expectation to the report table definition.

Which approach would allow using DLT expectations to validate all expected records are present in this table?

Define a SQL UDF that performs a left outer join on two tables, and check if this returns null values for report key values in a DLT expectation for the report table.

Define a function that performs a left outer join on validation_copy and report and report, and check against the result in a DLT expectation for the report table

Define a temporary table that perform a left outer join on validation_copy and report, and define an expectation that no report key values are null

Define a view that performs a left outer join on validation_copy and report, and reference this view in DLT expectations for the report table

NEW QUESTION 143
A workspace admin has created a new catalog called finance_data and wants to delegate permission management to a finance team lead without giving them full admin rights. Which privilege should be granted to the finance team lead?

ALL PRIVILEGES on the finance_data catalog.

Make the finance team lead a metastore admin.

GRANT OPTION privilege on the finance_data catalog.

MANAGE privilege on the finance_data catalog.

NEW QUESTION 144
A data company uses Databricks Unity Catalog and has multiple enterprise data sources, including PostgreSQL, Snowflake, and SQL Server. The central data platform team wants to configure Lakehouse Federation so analysts can query external tables directly in Databricks using Databricks SQL, without duplicating data. Which steps are necessary to configure Lakehouse Federation in a secure and governed manner?

Mirror the external datasets into Delta Lake using Auto Loader, and govern them using Data Lineage and System Tables.

Configure connections and foreign catalog in Unity Catalog, then grant access to foreign catalogs, schemas, and tables using Unity Catalog permissions.

Use Partner Connect to create linked datasets, and apply table ACLs at the source system to govern access through Databricks.

Create external locations and storage credentials to connect to each database, then register foreign tables in Unity Catalog.

NEW QUESTION 145
The DevOps team has configured a production workload as a collection of notebooks scheduled to run daily using the Jobs UI. A new data engineering hire is onboarding to the team and has requested access to one of these notebooks to review the production logic.
What are the maximum notebook permissions that can be granted to the user without allowing accidental changes to production code or data?

Can Manage

Can Edit

No permissions

Can Read

Can Run

NEW QUESTION 146
A data engineer is evaluating tools to build a production-grade data pipeline. The team must process change data from cloud object storage, filter out or isolate invalid records, and ensure the timely delivery of clean data to downstream consumers. The team is small, under tight deadlines, and wants to minimize operational overhead while keeping pipelines auditable and maintainable.
Which approach should the data engineer implement?

Ingest data directly into Delta tables via Spark jobs, apply data quality filters using UDFs, and use LDP for creating Materialized Views.

Use a hybrid approach: Ingest with Auto Loader into Bronze tables, then process using SQL queries in Databricks Workflows to generate cleaned Silver and Gold tables on a schedule.

Implement ingestion using Auto Loader with Structured Streaming, and manage invalid data handling and table updates using checkpointing and merge logic.

Use LDP to build declarative pipelines with Streaming Tables and Materialized Views, leveraging built-in support for data expectations and incremental processing.

NEW QUESTION 147
The downstream consumers of a Delta Lake table have been complaining about data quality issues impacting performance in their applications. Specifically, they have complained that invalid latitude and longitude values in the activity_details table have been breaking their ability to use other geolocation processes.
A junior engineer has written the following code to add CHECK constraints to the Delta Lake table:

A senior engineer has confirmed the above logic is correct and the valid ranges for latitude and longitude are provided, but the code fails when executed.
Which statement explains the cause of this failure?

Because another team uses this table to support a frequently running application, two-phase locking is preventing the operation from committing.

The activity details table already exists; CHECK constraints can only be added during initial table creation.

The activity details table already contains records that violate the constraints; all existing data must pass CHECK constraints in order to add them to an existing table.

The activity details table already contains records; CHECK constraints can only be added prior to inserting values into a table.

The current table schema does not contain the field valid coordinates; schema evolution will need to be enabled before altering the table to add a constraint.

NEW QUESTION 148
A data engineer is analyzing a large, partitioned retail dataset in Databricks, where each row represents a sale made by a salesperson. The dataset contains millions of records with the following schema:
sales_df: [salesperson_id: string, region: string, sale_amount: double, sale_date: date] The data engineer needs to generate a DataFrame that ranks salespeople within each region based on their total cumulative sales, with the highest seller ranked as 1. If multiple salespeople have the same total sales, they should share the same rank.
The data engineer wants to implement this logic using a PySpark window function and the dense_rank () function.
Which code snippet will perform this ranking?

NEW QUESTION 149
A data engineering team is setting up a Git project to automate integration tests using Databricks Asset Bundles and the Git provider’s CI/CD functionalities. When a pull containing changes to their pipleline is sent, they need to run a Job to test their data pipeline. What is the correct databricks bundle command sequence to be executed from the Git provider’s CI/CD automation for this task?

init, deploy, run, validate

validate, deploy, run

init, validate, deploy, run

deploy, run, validate

NEW QUESTION 150
A junior data engineer is working to implement logic for a Lakehouse table named silver_device_recordings. The source data contains 100 unique fields in a highly nested JSON structure.
The silver_device_recordings table will be used downstream to power several production monitoring dashboards and a production model. At present, 45 of the 100 fields are being used in at least one of these applications.
The data engineer is trying to determine the best approach for dealing with schema declaration given the highly-nested structure of the data and the numerous fields.
Which of the following accurately presents information about Delta Lake and Databricks that may impact their decision-making process?

The Tungsten encoding used by Databricks is optimized for storing string data; newly-added native support for querying JSON strings means that string types are always most efficient.

Because Delta Lake uses Parquet for data storage, data types can be easily evolved by just modifying file footer information in place.

Human labor in writing code is the largest cost associated with data engineering workloads; as such, automating table declaration logic should be a priority in all migration workloads.

Because Databricks will infer schema using types that allow all observed data to be processed, setting types manually provides greater assurance of data quality enforcement.

Schema inference and evolution on .Databricks ensure that inferred types will always accurately match the data types used by downstream systems.

NEW QUESTION 151
A data engineer is working on a Databricks notebook that requires several third-party Python libraries. Some of these are available on PyPI, while others are custom-developed and stored as local.wheel (.whl) and source (.tar.gz) files in an S3 bucket. The goal is to ensure all dependencies are installed and correctly available across multiple jobs running on any automated cluster in a Unity Catalog-enabled workspace. The engineer needs to install the required dependencies in a way that ensures a consistent environment setup across interactive notebooks and jobs and complies with workspace security policies (no internet access). Which approach should the engineer use to install and manage these dependencies while also ensuring reproducibility and compliance?

Use an init script on the cluster to install all dependencies using pip, referencing the local file system.

Install all dependencies manually in the driver node of an interactive cluster, then export the environment and reimport on job clusters using %conda.

Create a Python wheel file for the entire project, upload it to the Databricks Workspace Files or Volumes, and install it using a Cluster Library or pip install in a requirements.txt declared within a Databricks Asset Bundle.

Use %pip install in every notebook and job to install packages directly from PyPl and custom S3 paths.

NEW QUESTION 152
A table in the Lakehouse named customer_churn_params is used in churn prediction by the machine learning team. The table contains information about customers derived from a number of upstream sources. Currently, the data engineering team populates this table nightly by overwriting the table with the current valid values derived from upstream data sources.
The churn prediction model used by the ML team is fairly stable in production. The team is only interested in making predictions on records that have changed in the past 24 hours.
Which approach would simplify the identification of these changed records?

Apply the churn model to all rows in the customer_churn_params table, but implement logic to perform an upsert into the predictions table that ignores rows where predictions have not changed.

Convert the batch job to a Structured Streaming job using the complete output mode; configure a Structured Streaming job to read from the customer_churn_params table and incrementally predict against the churn model.

Calculate the difference between the previous model predictions and the current customer_churn_params on a key identifying unique customers before making new predictions; only make predictions on those customers not in the previous predictions.

Modify the overwrite logic to include a field populated by calling
spark.sql.functions.current_timestamp() as data are being written; use this field to identify records written on a particular date.

Replace the current overwrite logic with a merge statement to modify only those records that have changed; write logic to make predictions on the changed records identified by the change data feed.

NEW QUESTION 153
A Databricks job has been configured with 3 tasks, each of which is a Databricks notebook. Task A does not depend on other tasks. Tasks B and C run in parallel, with each having a serial dependency on task A.
If tasks A and B complete successfully but task C fails during a scheduled run, which statement describes the resulting state?

All logic expressed in the notebook associated with tasks A and B will have been successfully completed; some operations in task C may have completed successfully.

All logic expressed in the notebook associated with tasks A and B will have been successfully completed; any changes made in task C will be rolled back due to task failure.

All logic expressed in the notebook associated with task A will have been successfully completed; tasks B and C will not commit any changes because of stage failure.

Because all tasks are managed as a dependency graph, no changes will be committed to the Lakehouse until ail tasks have successfully been completed.

Unless all tasks complete successfully, no changes will be committed to the Lakehouse; because task C failed, all commits will be rolled back automatically.

NEW QUESTION 154
The data science team has created and logged a production model using MLflow. The model accepts a list of column names and returns a new column of type DOUBLE.
The following code correctly imports the production model, loads the customers table containing the customer_id key column into a DataFrame, and defines the feature columns needed for the model.

Which code block will output a DataFrame with the schema “customer_id LONG, predictions DOUBLE”?

model.predict(df, columns)

df.map(lambda x:model(x[columns])).select(“customer_id, predictions”)

df.select(“customer_id”, model(*columns).alias(“predictions”))

df.apply(model, columns).select(“customer_id, predictions”)

df.select(“customer_id”, pandas_udf(model, columns).alias(“predictions”))

NEW QUESTION 155
A CHECK constraint has been successfully added to the Delta table named activity_details using the following logic:

A batch job is attempting to insert new records to the table, including a record where latitude =
45.50 and longitude = 212.67.
Which statement describes the outcome of this batch insert?

The write will fail when the violating record is reached; any records previously processed will be recorded to the target table.

The write will fail completely because of the constraint violation and no records will be inserted into the target table.

The write will insert all records except those that violate the table constraints; the violating records will be recorded to a quarantine table.

The write will include all records in the target table; any violations will be indicated in the boolean column named valid_coordinates.

The write will insert all records except those that violate the table constraints; the violating records will be reported in a warning log.

NEW QUESTION 156
Where in the Spark UI can one diagnose a performance problem induced by not leveraging predicate push-down?

In the Executor’s log file, by gripping for “predicate push-down”

In the Stage’s Detail screen, in the Completed Stages table, by noting the size of data read from the Input column

In the Storage Detail screen, by noting which RDDs are not stored on disk

In the Delta Lake transaction log. by noting the column statistics

In the Query Detail screen, by interpreting the Physical Plan

NEW QUESTION 157
A data engineer is designing a Lakeflow Declarative Pipeline to process streaming order data.
The pipeline uses Auto Loader to ingest data and must enforce data quality by ensuring customer_id and amount are greater than zero. Invalid records should be dropped. Which Lakeflow Declarative Pipelines configurations implement this requirement using Python?

@dlt.table
def silver_orders():
return (
dlt.read_stream(“bronze_orders”)
.expect_or_drop(“valid_customer”, “customer_id IS NOT NULL”)
.expect_or_drop(“valid_amount”, “amount > 0”)
)

@dlt.table
@dlt.expect(“valid_customer”, “customer_id IS NOT NULL”)
@dlt.expect(“valid_amount”, “amount > 0”)
def silver_orders():
return dlt.read_stream(“bronze_orders”)

@dlt.table
def silver_orders():
return (
dlt.read_stream(“bronze_orders”)
.expect(“valid_customer”, “customer_id IS NOT NULL”)
.expect(“valid_amount”, “amount > 0”)
)

@dlt.table
@dlt.expect_or_drop(“valid_customer”, “customer_id IS NOT NULL”)
@dlt.expect_or_drop(“valid_amount”, “amount > 0”)
def silver_orders():
return dlt.read_stream(“bronze_orders”)

NEW QUESTION 158
A data engineer is designing a secure data sharing strategy for their organization. The company needs to share sensitive customer analytics data with two different partners. Partner A uses Databricks with Unity Catalog enabled, while Partner B uses Apache Spark on AWS without Databricks. How should the company implement secure data sharing for these scenarios?

For Partner A, implement Databricks-to-Databricks sharing (D2D) with Unit Catalog integration and no-token exchange system. For Partner B, use open sharing protocol (D2O) with either bearer tokens or OIDC federation for authentication, ensuring both approaches maintain robust security and governance.

Both partners should use the same Delta Sharing approach since security requirements are identical. You should create bearer tokens for both partners and use the open sharing protocol (D2O) for maximum compatibility.

Open sharing protocol (D2O) should be used for both partners because it provides better security than D2D sharing. The bearer token approach is always more secure than Unity Catalog’s native authentication.

Databricks-to-Databricks sharing (D2D) can only be used within the same cloud provider, so you must use open sharing (D2O) for any cross-cloud scenarios. Unit Catalog governance is not available when sharing with external platforms.

NEW QUESTION 159
The Databricks workspace administrator has configured interactive clusters for each of the data engineering groups. To control costs, clusters are set to terminate after 30 minutes of inactivity.
Each user should be able to execute workloads against their assigned clusters at any time of the day.
Assuming users have been added to a workspace but not granted any permissions, which of the following describes the minimal permissions a user would need to start and attach to an already configured cluster.

“Can Manage” privileges on the required cluster

Workspace Admin privileges, cluster creation allowed. “Can Attach To” privileges on the required cluster

Cluster creation allowed. “Can Attach To” privileges on the required cluster

“Can Restart” privileges on the required cluster

Cluster creation allowed. “Can Restart” privileges on the required cluster

NEW QUESTION 160
A data engineering team needs to implement a tagging system for their tables as part of an automated ETL process, and needs to apply tags programmatically to tables in Unity Catalog.
Which SQL command adds tags to a table programmatically?

ALTER TABLE table_name SET TAGS (‘key1’ = ‘value1’, ‘key2’ = ‘value2’);

APPLY TAGS ON table_name VALUES (‘key1’ = ‘value1’, ‘key2’ = ‘value2’);

COMMENT ON TABLE table_name TAGS (‘key1’ = ‘value1’, ‘key2’ = ‘value2’);

SET TAGS FOR table_name AS (‘key1’ = ‘value1’, ‘key2’ = ‘value2’);

NEW QUESTION 161
A data engineer is implementing liquid clustering on a Delta Lale table and needs to understand how it affects data management operations. The table will be updated frequently with new data.
The table is an external table and not managed by Unity Catalog. How does liquid clustering in Delta Lake handle new data that is inserted after the initial table creation?

New data is rejected if it doesn’t match the clustering pattern.

New data is automatically clustered during write operations.

New data is written to a staging area and clustered during scheduled maintenance.

New data remains unclustered until the next OPTIMIZE operation.

Get 100% Real Free Databricks Certification Certified-Data-Engineer-Professional Sample Questions: https://www.practicematerial.com/Certified-Data-Engineer-Professional-exam-materials.html

Databricks Certified-Data-Engineer-Professional Exam Syllabus Topics:

Leave a Reply Cancel reply