Databricks Databricks-Certified-Data-Engineer-Associate Databricks Certified Data Engineer Associate Exam Exam Practice Test

According to the medallion lakehouse architecture, gold tables are the final layer of data that powers analytics, machine learning, and production applications. They are often highly refined and aggregated, containing data that has been transformed into knowledge, rather than just information. Silver tables, on the other hand, are the intermediate layer of data that represents a validated, enriched version of the raw data from the bronze layer. They provide an enterprise view of all its key business entities, concepts and transactions, but they may not have all the aggregations and calculations that are required for specific use cases. Therefore, gold tables are more likely to contain aggregations than silver tables. References:

What is the medallion lakehouse architecture?

What is a Medallion Architecture?

Delta Live Tables is a declarative framework for building reliable, maintainable, and testable data processing pipelines. You define the transformations to perform on your data and Delta Live Tables manages task orchestration, cluster management, monitoring, data quality, and error handling. Delta Live Tables supports both SQL and Python as the languages for defining your datasets and expectations. Delta Live Tables also supports both streaming and batch sources, and can handle both append-only and upsert data patterns. Delta Live Tables follows the medallion lakehouse architecture, which consists of three layers of data: bronze, silver, and gold. Therefore, migrating to Delta Live Tables does not require any of the changes listed in the options B, C, D, or E. The data engineer and data analyst can use the same languages, sources, and architecture as before, and simply declare their datasets and expectations using Delta Live Tables syntax. References:

What is Delta Live Tables?

Transform data with Delta Live Tables

What is the medallion lakehouse architecture?

A webhook alert destination is a way to send notifications to external applications or services via HTTP requests. A data engineer can use a webhook alert destination to notify their entire team via a messaging webhook, such as Slack or Microsoft Teams, whenever the number of NULL values in the input data reaches 100. To set up a webhook alert destination, the data engineer needs to do the following steps:

In the Databricks SQL workspace, navigate to the Settings gear icon and select SQL Admin Console.

Click Alert Destinations and click Add New Alert Destination.

Select Webhook and enter the webhook URL and the optional custom template for the notification message.

Click Create to save the webhook alert destination.

In the Databricks SQL editor, create or open the query that returns the number of input records containing unexpected NULL values.

Click the Create Alert icon above the editor window and configure the alert criteria, such as the value column, the condition, and the threshold.

In the Notification section, select the webhook alert destination that was created earlier and click Create Alert. References: What are Databricks SQL alerts?, Monitor alerts, Monitoring Your Business with Alerts, Using Automation Runbook Webhooks To Alert on Databricks Status Updates.

https://spark.apache.org/docs/latest/api/python/reference/pyspark.ss/api/pyspark.sql.streaming.DataStreamWriter.trigger.html

The < = > operator performs null-safe equality in Databricks SQL. It returns TRUE when both operands contain the same non-NULL value and also when both operands are NULL. It returns FALSE when only one operand is NULL. By contrast, the standard equality operator returns UNKNOWN when either side is NULL, so it cannot match two NULL values in a WHERE condition. Option C implements inequality logic and does not provide null-safe equality. Option D can incorrectly treat a genuine empty string as equivalent to NULL, changing the meaning of the data. Therefore, option A is the only predicate that preserves SQL values while implementing the required NULL comparison behavior. This question was also checked against the existing Word question bank.

================

 Option A is the correct answer because it uses the FILTER higher-order function correctly to filter out employees with more than 5 years of experience from the array column “employees”. It applies a lambda function i - > i.years_exp > 5 that checks if the years of experience of each employee in the array is greater than 5. If this condition is met, the employee is included in the new array column “exp_employees”.

The use of higher-order functions like FILTER can be referenced from Databricks documentation on Higher-Order Functions.

To send the Databricks Job owner an email in the case that the Job fails, the best approach is to set up an Alert in the Job page. This way, the Job owner can configure the email address and the notification type for the Job failure event. The other options are either not feasible, not reliable, or not relevant for this task. Manually programming an alert system in each cell of the Notebook is tedious and error-prone. Setting up an Alert in the Notebook is not possible, as Alerts are only available for Jobs and Clusters. There is a way to notify the Job owner in the case of Job failure, so option D is incorrect. MLflow Model Registry Webhooks are used for model lifecycle events, not Job events, so option E is not applicable. References:

Add email and system notifications for job events

Alerts

MLflow Model Registry Webhooks

Databricks documentation for Unity Catalog lineage states that lineage is captured across queries run on Databricks , is supported for all languages , and is tracked down to the column level . It also explicitly says that lineage data includes related notebooks, jobs, and dashboards , and that the lineage can be visualized in Catalog Explorer in near real time as an interactive graph. This directly matches option D. The value of this feature is that it helps engineers understand where a table’s data came from, which upstream notebooks or jobs produced it, and which downstream assets, including dashboards, depend on it. Column-level lineage adds another layer of traceability by showing how specific fields are derived through transformations, which is especially useful for impact analysis, governance, and troubleshooting. Options A, B, and C each remove documented capabilities that Unity Catalog lineage actually supports. Therefore, the Databricks-documented answer is the full interactive graph across Delta tables and related assets, with column-level tracking included.

=========

In Unity Catalog, the Metastore Admin role has the highest level of authority within a metastore and is responsible for governing all data assets registered in that metastore. Metastore admins can transfer ownership of catalogs , manage privileges across all securable objects (catalogs, schemas, tables, views), and administer storage credentials, external locations, and Delta Sharing objects such as shares and recipients. This makes the role essential when a platform owner departs and continuity must be maintained at an organizational level. Workspace admins (option B) manage workspace-level settings but do not automatically have authority over Unity Catalog ownership unless explicitly granted. Catalog owners (option D) are limited to a single catalog and cannot perform actions across the entire metastore. Account admins (option A) operate at the account level and are primarily responsible for creating metastores and assigning admins, not for day-to-day governance within an existing metastore. Databricks documentation clearly defines the Metastore Admin as the role required to centrally manage ownership, privileges, and data sharing across the metastore in Databricks.

For interactive notebook development, Databricks distinguishes between all-purpose compute and job compute . All-purpose compute is designed for analysis, notebook development, and interactive workloads , while job compute is intended for automated scheduled or triggered jobs. Because the engineer is actively developing a proof of concept in a notebook and wants real-time feedback, an all-purpose cluster is the right compute type. Adding autoscaling makes it better suited to the observed usage spikes, because the cluster can expand when notebook execution demands more resources and scale down afterward, reducing waste compared with a large fixed-size cluster. That makes option B the best answer. Option A keeps the interactive development model, but the fixed large size is less efficient. Options C and D use job clusters, which are better aligned with production jobs rather than iterative notebook-based development. Databricks documentation consistently positions all-purpose compute for collaborative and interactive development, and autoscaling is a standard mechanism to handle variable workloads more efficiently.

=========

To find the owner of a table in Databricks, one can utilize the Data Explorer feature. The Data Explorer provides detailed information about various data objects, including tables. By navigating to the specific table ' s page in Data Explorer, a data engineer can review the Owner field, which identifies the individual or role that owns the table. This information is crucial for obtaining the necessary permissions or for any administrative actions related to the table.

The engineer should inspect the job’s maximum concurrent-runs configuration and its queueing setting. max_concurrent_runs controls how many active runs of the same job can execute simultaneously. When that limit has already been reached, Databricks can skip the newly triggered run if queueing is disabled. When queueing is enabled, the additional run waits until capacity becomes available instead of being skipped. Spot-instance availability might delay or prevent compute startup, but it would not normally produce a job-level concurrency message. SQL warehouse permissions affect SQL task execution after a run begins, while timeout_seconds determines how long a task may run before timing out. Therefore, option C directly addresses the reported run state. This candidate was also compared against the existing Word question bank.

================

Option C extracts each JSON field into a separate Silver-table column and casts age to the appropriate integer type. get_json_object accepts a JSON string and a JSONPath expression rooted at $; paths such as $.user_id and $.age therefore identify the required top-level fields correctly. This produces analytics-ready columns and prevents downstream queries from repeatedly parsing the original JSON string. Option A returns one nested struct and incorrectly defines age as STRING, so further projection or casting would still be required. Option B attempts field notation directly on a STRING column, which is not valid until the JSON has been parsed into a structured type. Option D omits the required $ JSONPath root and leaves age uncast. Therefore, option C most completely standardizes the source data for the Silver layer.

================

The correct command to grant the necessary permission on the entire database to the new team is to use the GRANT USAGE command. The GRANT USAGE command grants the principal the ability to access the securable object, such as a database, schema, or table. In this case, the securable object is the database customers, and the principal is the group team. By granting usage on the database, the team will be able to see what tables already exist in the database. Option E is the only option that uses the correct syntax and the correct privilege type for this scenario. Option A uses the wrong privilege type (VIEW) and the wrong securable object (CATALOG). Option B uses the wrong privilege type (CREATE), which would allow the team to create new tables in the database, but not necessarily see the existing ones. Option C uses the wrong securable object (CATALOG) and the wrong principal (customers). Option D uses the wrong securable object (team) and the wrong principal (customers). References: GRANT, Privilege types, Securable objects, Principals

When Automatically detect column types is disabled during file upload, Databricks does not infer specialized data types from the CSV values. Instead, every uploaded column is created as STRING. This behavior prevents values that resemble numbers, dates, or Boolean values from being automatically assigned potentially incorrect types. The engineer can subsequently transform or cast individual columns into the required target types as part of a controlled Silver-layer process. Option B is incorrect because partial numeric inference does not occur when automatic detection is disabled. Option C is incorrect because Databricks can create the table without manually supplied types by using STRING for every column. Option D is also incorrect because disabling detection determines the schema behavior for the table creation operation. Therefore, option A accurately describes the result.

================

The command databricks bundle deploy deploys the bundle’s local files, artifacts, and resource definitions to the configured remote Databricks workspace. Databricks documents this command as the deployment operation for Declarative Automation Bundles, and a specific target can be selected with the -t or --target option. The validate command checks whether the bundle configuration is valid but does not create or update workspace resources. The run command executes a resource that has already been deployed; it is not the deployment step. The init command creates a new bundle project from a template, while bundle deployment is not a valid command combination. Because the question asks for the single command that sends local bundle assets to the target workspace, option C is correct.

================

A row-filter function must return a Boolean value indicating whether each row is visible to the current user. The function in option A returns true for members of the account-level all_regions group, allowing them to see every row. For other users, it returns the result of region = ' EU ' , limiting visibility to European records. is_account_group_member checks direct or indirect membership in an account-level group. The ALTER TABLE ... SET ROW FILTER ... ON (region) statement then associates the function with the table and passes the region column to it for every query. A column mask transforms displayed column values rather than removing rows. The object is a table, not a view, and USING COLUMNS is not the correct row-filter attachment syntax. Therefore, option A is correct.

================

Auto Loader in Databricks utilizes Spark Structured Streaming for processing data incrementally. This allows Auto Loader to efficiently ingest streaming or batch data at scale and to recognize new data as it arrives in cloud storage. Spark Structured Streaming provides the underlying engine that supports various incremental data loading capabilities like schema inference and file notification mode, which are crucial for the dynamic nature of data lakes.

A SQL Serverless Warehouse is the most suitable option for running SQL-based exploratory data analysis at scale while minimizing operational and cost overhead. Serverless SQL warehouses are fully managed by Databricks , meaning Databricks automatically provisions and scales compute resources, applies Photon acceleration , and optimizes query execution without requiring the user to manage infrastructure. This makes them ideal for workloads involving large numbers of ad hoc or interactive SQL queries , which is common during EDA. Because the data resides in a custom-defined cloud network , serverless SQL warehouses can still securely access governed data when Unity Catalog and networking requirements are satisfied. All-purpose clusters (option A) are designed for collaborative development and mixed workloads, not cost-efficient high-concurrency SQL querying. Classic SQL warehouses (option D) are legacy and lack the performance and cost optimizations of newer serverless offerings. Pro SQL warehouses (option B) require user-managed sizing decisions, whereas serverless warehouses optimize both performance and cost automatically. Databricks documentation recommends SQL Serverless Warehouses for fast, scalable, and cost-effective SQL analytics.

=========

Databricks describes the Bronze layer in the Medallion Architecture as the raw ingestion layer , where source data is landed with minimal validation or transformation so that the original records are preserved for auditability and reprocessing. This is especially important for sources like Kafka clickstream events and file-based product catalogs, because downstream logic such as cleansing, deduplication, conformance, and business modeling should happen later in Silver and Gold layers. Bronze data is commonly stored in an append-only pattern and may include basic ingestion metadata, but it should not be heavily transformed at this stage. Databricks explicitly recommends limiting cleanup and validation in Bronze and using Silver for validation and deduplication. That makes option C the best match to Databricks guidance. Options A, B, and D all skip or misuse the Bronze layer, which reduces traceability and makes recovery or replay harder if business logic changes later.

=========

For large-scale batch ETL workloads , Databricks documentation recommends using job clusters that are created specifically for a job run and terminated automatically when the job completes. A job cluster with autoscaling enabled provides the best balance of performance, reliability, and cost efficiency for long-running nightly pipelines. Autoscaling allows the cluster to dynamically add or remove worker nodes based on the workload demands, ensuring sufficient parallelism to process very large JSON datasets efficiently while avoiding overprovisioning when demand decreases. This is especially important when processing raw data into Delta tables, where shuffle-heavy transformations and writes benefit from multiple workers. Single-node clusters (option B) are not suitable for very large volumes of data and risk excessive runtimes or job failures. High-concurrency clusters (option C) are optimized for interactive and concurrent SQL queries, not long-running batch ETL jobs. Always-on all-purpose clusters (option D) increase costs unnecessarily and are intended for interactive development, not scheduled production pipelines. Databricks best practices clearly position autoscaling job clusters as the preferred solution for reliable, cost-effective batch ETL in production on Databricks.

Option A enables predictive optimization, which is designed to eliminate manual maintenance scheduling for Unity Catalog managed tables. Databricks evaluates table activity and automatically runs operations such as OPTIMIZE, VACUUM, and ANALYZE when beneficial, using serverless jobs compute. Predictive optimization can be enabled at multiple hierarchy levels, allowing tables to inherit the applicable setting. Auto Loader schema evolution handles changes in incoming file schemas but does not schedule table optimization. Liquid clustering improves data organization and query pruning, but it does not independently provide automated stale-file removal. Optimized writes and auto compaction reduce the creation of small files during write operations, but they do not replace adaptive VACUUM scheduling and the broader maintenance capabilities of predictive optimization. Therefore, option A directly satisfies the requirement for platform-managed table maintenance.

================

This question’s options do not include the most precise Unity Catalog answer, which would normally be the MANAGE privilege on the schema, because Databricks documents that MANAGE allows a principal to grant and revoke privileges on an object without automatically granting all data-access privileges on that object. However, since MANAGE is not one of the answer choices, the best available answer is D, Schema Owner . Databricks states that schema owners can grant and revoke permissions on the schema, and schema-level administration is a documented responsibility of the schema owner. Option A is incorrect because USE CATALOG and USE SCHEMA only allow object access/navigation and do not confer privilege-management rights. Option B is too broad because a catalog owner governs the entire catalog scope, not just one schema. Option C is too narrow because a table owner controls only one table, not various objects across a schema. So, among the choices provided, Schema Owner is the closest Databricks-aligned answer, though the cleanest real-world implementation would be MANAGE on the schema .

=========

Databricks separates workspace-management services from data processing. Notebook source files stored as workspace objects are managed in the Databricks control plane and are encrypted at rest. When the scheduled job starts, Databricks orchestrates the run from the control plane, but the notebook commands execute on compute resources in the compute plane. The compute plane is where Spark transformations, Python code, and other data-processing operations run. Unity Catalog governs data and AI assets but is not the execution environment or the general storage location for workspace notebook source. Delta Lake is a table-storage layer and does not execute notebook code. Option D is also incorrect because Databricks does not describe workspace notebook source as unencrypted. Therefore, option C accurately represents the separation between notebook storage and workload execution.

COPY INTO is idempotent by default and tracks files that have already been loaded into the target table. A corrected file uploaded under the same name and path can therefore be treated as previously processed and skipped. The reliable pattern is to publish the correction under a new unique filename so that ingestion detects it as a new file. The pipeline can then use a business key with MERGE, UPDATE, or equivalent transformation logic to apply the corrected values to the target Delta table. Overwriting or recreating the complete table risks unnecessary data loss, increases processing cost, and disrupts downstream consumers. Reloading every historical source file is also inefficient and can introduce duplicates. Therefore, option B supports incremental ingestion while applying corrections safely and efficiently.

================

A table is a data entity that is stored in a physical location and can be accessed by other data engineers in other sessions. A table can be created from one or more tables using the CREATE TABLE or CREATE TABLE AS SELECT commands. A table can also be registered from an existing DataFrame using the spark.catalog.createTable method. A table can be queried using SQL or DataFrame APIs. A table can also be updated, deleted, or appended using the MERGE INTO command or the DeltaTable API. References:

Create a table

Create a table from a query result

Register a table from a DataFrame

[Query a table]

[Update, delete, or merge into a table]

In Unity Catalog, ownership is the primary mechanism for delegating full administrative control of a securable object. The owner of a schema can grant and revoke privileges on that schema and on all objects contained within it (such as tables and views), without needing to be a workspace admin or metastore admin. Transferring ownership of main.marketing to the mkt-admins group therefore aligns precisely with the requirement to delegate day-to-day permission management at the schema scope. Granting MANAGE at the metastore level (option B) would be overly permissive, enabling global administration across all schemas and objects, which violates the principle of least privilege. Simply granting USE SCHEMA and MODIFY (option C) does not confer the ability to manage grants for other users. Making the group workspace admins (option D) unnecessarily elevates privileges beyond Unity Catalog’s data governance model. Unity Catalog documentation emphasizes using ownership transfer to delegate administrative responsibilities at the appropriate scope while maintaining centralized governance in Databricks.

=========

Workspace-specific deployment settings should be defined under each environment in the targets section of databricks.yml. A bundle target represents a deployment environment such as development, staging, or production. Each target can contain its own workspace mapping, including the workspace host and an optional root_path. This structure allows one bundle codebase to be deployed predictably to different environments without embedding infrastructure details in notebooks or pipeline source code. A README file is documentation and is not interpreted as bundle configuration. Hardcoding workspace details in Python couples transformation logic to a particular environment. Global local environment variables are machine-specific and do not provide a complete, version-controlled bundle definition. Therefore, option C correctly places the workspace-specific settings in the declarative configuration used during validation and deployment.

================

https://www.databricks.com/blog/2021/10/20/introducing-sql-user-defined-functions.html

 The keyword that can be used to compact the small files associated with a Delta table is OPTIMIZE. The OPTIMIZE command performs file compaction on a Delta table by rewriting a set of small files into a set of larger files1. This can improve the performance of queries that scan the table by reducing the number of files that need to be read and the amount of metadata that needs to be processed1. The OPTIMIZE command can also optionally sort the data within each file by a given set of columns, which can further improve the query performance by enabling data skipping and predicate pushdown1. The OPTIMIZE command can be applied to the whole table or to a specific partition of the table1.

The other keywords are not suitable for compacting the small files associated with a Delta table. REDUCE is a keyword used in the SQL syntax for aggregating data using a user-defined function2. COMPACTION is not a valid keyword in SQL or Python. REPARTITION is a keyword used in the Python syntax for changing the number of partitions of a DataFrame or an RDD3. VACUUM is a keyword used to remove files that are no longer referenced by a Delta table and are older than a retention threshold4.

1: OPTIMIZE | Databricks on AWS

2: REDUCE | Databricks on AWS

3: repartition | Databricks on AWS

4: VACUUM | Databricks on AWS

Auto Loader provides a Structured Streaming source called cloudFiles that can process new data files as they arrive in cloud storage without any additional setup. Auto Loader uses a scalable key-value store to track ingestion progress and ensure exactly-once semantics. Auto Loader can ingest various file formats and load them into Delta Lake tables. Auto Loader is recommended for incremental data ingestion with Delta Live Tables, which extends the functionality of Structured Streaming and allows you to write declarative Python or SQL code to deploy a production-quality data pipeline. References: What is Auto Loader?, What is Auto Loader? | Databricks on AWS, Solved: How does Auto Loader ingest data? - Databricks - 5629

The array functions from Spark SQL are a subset of the collection functions that operate on array columns1. They provide an ability to work with complex, nested data ingested from JSON files or other sources2. For example, the explode function can be used to transform an array column into multiple rows, one for each element in the array3. The array_contains function can be used to check if a value is present in an array column4. The array_join function can be used to concatenate all elements of an array column with a delimiter. These functions can be useful for processing JSON data that may have nested arrays or objects. References: 1: Spark SQL, Built-in Functions - Apache Spark 2: Spark SQL Array Functions Complete List - Spark By Examples 3: Spark SQL Array Functions - Syntax and Examples - DWgeek.com 4: Spark SQL, Built-in Functions - Apache Spark : Spark SQL, Built-in Functions - Apache Spark : [Working with Nested Data Using Higher Order Functions in SQL on Databricks - The Databricks Blog]

With schema evolution enabled, Auto Loader detects source fields that are not present in the current schema and evolves the destination schema to include them. The new userAgent field is therefore added to the Delta table as a column, and values from newly processed records are written to it. Existing rows cannot be retroactively populated because the earlier source records did not contain that field, so they receive NULL for the newly added column. The column is consequently nullable unless a later transformation explicitly enforces another constraint. Option A describes behavior without suitable schema evolution. Option B incorrectly claims that historical rows receive a default value and that the column becomes non-nullable. Option D contradicts schema-evolution behavior. Therefore, option C correctly describes how the new JSON field is handled.

The best action that the data engineer can perform to improve the start up time for the clusters used for the Job is to use clusters that are from a cluster pool. A cluster pool is a set of idle clusters that can be used by jobs or interactive sessions. By using a cluster pool, the data engineer can avoid the cluster creation time and reduce the latency of the tasks. Cluster pools also offer cost savings and resource efficiency, as they can be shared by multiple users and jobs.

Option A is not relevant, as endpoints available in Databricks SQL are used for creating and managing SQL analytics workloads, not for improving cluster start up time.

Option B is not correct, as jobs clusters and all-purpose clusters have similar start up times. Jobs clusters are clusters that are dedicated to run a single job and are terminated when the job is completed. All-purpose clusters are clusters that can be used for multiple purposes, such as interactive sessions, notebooks, or multiple jobs. Both types of clusters can benefit from using a cluster pool.

Option C is not advisable, as configuring the clusters to be single-node will reduce the parallelism and performance of the tasks. Single-node clusters are clusters that have only one worker node and are typically used for testing or development purposes. They are not suitable for running production jobs that require high scalability and fault tolerance.

Option E is not helpful, as configuring the clusters to autoscale for larger data sizes will not affect the start up time of the clusters. Autoscaling is a feature that allows clusters to dynamically adjust the number of worker nodes based on the workload. It can help optimize the resource utilization and cost efficiency of the clusters, but it does not speed up the cluster creation process.

Cluster Pools

Jobs

Clusters

[Databricks Data Engineer Professional Exam Guide]

The Databricks web application is the user interface that allows you to create and manage workspaces, clusters, notebooks, jobs, and other resources. It is hosted completely in the control plane of the classic Databricks architecture, which includes the backend services that Databricks manages in your Databricks account. The other options are part of the compute plane, which is where your data is processed by compute resources such as clusters. The compute plane is in your own cloud account and network. References: Databricks architecture overview, Security and Trust Center QUESTION NO: 4

Which of the following benefits of using the Databricks Lakehouse Platform is provided by Delta Lake?

A. The ability to manipulate the same data using a variety of languages

B. The ability to collaborate in real time on a single notebook

C. The ability to set up alerts for query failures

D. The ability to support batch and streaming workloads

E. The ability to distribute complex data operations

Answer: D

Delta Lake is the optimized storage layer that provides the foundation for storing data and tables in the Databricks lakehouse. Delta Lake is fully compatible with Apache Spark APIs, and was developed for tight integration with Structured Streaming, allowing you to easily use a single copy of data for both batch and streaming operations and providing incremental processing at scale1. Delta Lake supports upserts using the merge operation, which enables you to efficiently update existing data or insert new data into your Delta tables2. Delta Lake also provides time travel capabilities, which allow you to query previous versions of your data or roll back to a specific point in time3. References: 1: What is Delta Lake? | Databricks on AWS 2: Upsert into a table using merge | Databricks on AWS 3: [Query an older snapshot of a table (time travel) | Databricks on AWS]

Learn more

Option A is the correct answer because it shows the result of an INNER JOIN between the two tables. An INNER JOIN returns only the rows that have matching values in both tables based on the join condition. In this case, the join condition is ON a.customer_id = c.customer_id, which means that only the rows that have the same customer ID in both tables will be included in the output. The output will have four columns: customer_id, name, account_id, and overdraft_amt. The output will have four rows, corresponding to the four customers who have accounts in the account table.

The use of INNER JOIN can be referenced from Databricks documentation on SQL JOIN or from other sources like W3Schools or GeeksforGeeks.

Option A is the supported migration path for bringing existing workspace resources under Declarative Automation Bundle management. The bundle generate command creates bundle configuration for supported existing resources, including jobs, pipelines, and dashboards, and can download referenced artifacts where applicable. The bundle deployment bind command then associates the bundle resource key with the existing workspace resource so that future deployments update that resource rather than creating a duplicate. The completed bundle project can be committed to Git and promoted through CI/CD. Exporting REST API JSON does not create a complete bundle workflow, manually recreating every resource is unnecessary, and bundle init creates a project from a template but does not automatically discover existing resources. Therefore, option A provides the intended generation and binding process.

================

Option A is correct because Lakeflow Connect provides a built-in, fully managed Salesforce connector. It ingests Salesforce data into Databricks, supports incremental processing, and publishes governed destination tables in Unity Catalog. Managed SaaS connectors handle source-specific authentication, incremental reads, schema evolution, and automated retries, reducing the custom engineering required for API pagination, state tracking, and failure recovery. Calling the Salesforce REST API from a notebook would require the team to develop and maintain those capabilities itself. Auto Loader is designed to discover and incrementally process files arriving in cloud object storage; it does not connect directly to Salesforce. Using an exported Amazon S3 path would also require a separate export system outside the requested managed Databricks ingestion experience. Therefore, option A is the low-code capability that directly satisfies the Salesforce ingestion requirement.

================

Option B keeps environment differences entirely in the bundle configuration. Declarative Automation Bundles support custom variables that can be referenced by resource definitions, making the same job and notebook definitions reusable. Databricks targets represent deployment environments such as development, test, and production, and target-level settings take precedence over top-level settings, including variable overrides. This allows the team to deploy the same codebase while supplying different workspace paths, compute identifiers, catalog names, or other values for each environment. Editing deployed jobs in the workspace UI creates configuration drift and breaks the bundle as the authoritative source. Separate Git branches duplicate configuration and promotion logic, while notebook parameters move environment logic into application code. Therefore, defining variables and overriding them through targets is the correct configuration-only approach.

================

 To set up the new task to run a new notebook prior to the original task in a single-task Job, the data engineer can use the following approach: In the existing Job, create a new task that corresponds to the new notebook that needs to be run. Set up the new task with the appropriate configuration, specifying the notebook to be executed and any necessary parameters or dependencies. Once the new task is created, designate it as a dependency of the original task in the Job configuration. This ensures that the new task is executed before the original task.

The expected behavior when a batch of data containing data that violates the expectation is processed is that the job will fail. This is because the expectation clause has the ON VIOLATION FAIL UPDATE option, which means that if any record in the batch does not meet the expectation, the entire batch will be rejected and the job will fail. This option is useful for enforcing strict data quality rules and preventing invalid data from entering the target dataset.

Option A is not correct, as the ON VIOLATION FAIL UPDATE option does not drop the records that violate the expectation, but fails the entire batch. To drop the records that violate the expectation and record them as invalid in the event log, the ON VIOLATION DROP RECORD option should be used.

Option C is not correct, as the ON VIOLATION FAIL UPDATE option does not drop the records that violate the expectation, but fails the entire batch. To drop the records that violate the expectation and load them into a quarantine table, the ON VIOLATION QUARANTINE RECORD option should be used.

Option D is not correct, as the ON VIOLATION FAIL UPDATE option does not add the records that violate the expectation, but fails the entire batch. To add the records that violate the expectation and record them as invalid in the event log, the ON VIOLATION LOG RECORD option should be used.

Option E is not correct, as the ON VIOLATION FAIL UPDATE option does not add the records that violate the expectation, but fails the entire batch. To add the records that violate the expectation and flag them as invalid in a field added to the target dataset, the ON VIOLATION FLAG RECORD option should be used.

Delta Live Tables Expectations

[Databricks Data Engineer Professional Exam Guide]

 Option C is the correct answer because Parquet files have a well-defined schema that is embedded within the data itself. This means that the data types and column names of the Parquet files are automatically detected and preserved when creating an external table from them. This also enables the use of SQL and other structured query languages to access and analyze the data. CSV files, on the other hand, do not have a schema embedded in them, and require specifying the schema explicitly or inferring it from the data when creating an external table from them. This can lead to errors or inconsistencies in the data types and column names, and also increase the processing time and complexity.

 CREATE TABLE AS SELECT, Parquet Files, CSV Files, Parquet vs. CSV

Bronze tables are the first layer of a medallion architecture, which is a data design pattern used to organize data in a lakehouse. Bronze tables contain raw data ingested from various sources, such as RDBMS data, JSON files, IoT data, etc. The table structures in this layer correspond to the source system table structures “as-is”, along with any additional metadata columns that capture the load date/time, process ID, etc. The only transformation applied to the raw data in this layer is to apply a schema, which defines the column names and data types of the table. The schema can be inferred from the data source or specified explicitly. Applying a schema to the raw data enables the use of SQL and other structured query languages to access and analyze the data. Therefore, option E is the correct answer. References: What is a Medallion Architecture?, Raw Data Ingestion into Delta Lake Bronze tables using Azure Synapse Mapping Data Flow, Apache Spark + Delta Lake concepts, Delta Lake Architecture & Azure Databricks Workspace.

JSON data is a text-based format that represents data as a collection of name-value pairs. By default, when Auto Loader infers the schema of JSON data, it treats all columns as strings. This is because JSON data can have varying data types for the same column across different files or records, and Auto Loader does not attempt to reconcile these differences. For example, a column named “age” may have integer values in some files, but string values in others. To avoid data loss or errors, Auto Loader infers the column as a string type. However, Auto Loader also provides an option to infer more precise column types based on the sample data. This option is called cloudFiles.inferColumnTypes and it can be set to true or false. When set to true, Auto Loader tries to infer the exact data types of the columns, such as integers, floats, booleans, or nested structures. When set to false, Auto Loader infers all columns as strings. The default value of this option is false. References: Configure schema inference and evolution in Auto Loader, Schema inference with auto loader (non-DLT and DLT), Using and Abusing Auto Loader’s Inferred Schema, Explicit path to data or a defined schema required for Auto loader.

 To append a new record to an existing Delta table, you can use the INSERT INTO statement with the VALUES clause. This statement will insert one or more rows into the table with the specified values. Option A is the only code block that follows this syntax correctly. Option B is incorrect, as it uses the UNION operator, which will return a new table that is the union of two tables, not append to an existing table. Option C is incorrect, as it uses the INSERT VALUES statement, which is not a valid SQL syntax. Option D is incorrect, as it uses the UPDATE statement, which will modify existing rows in the table, not append new rows. Option E is incorrect, as it uses the UPDATE VALUES statement, which is also not a valid SQL syntax. References: Insert data into a table using SQL | Databricks on AWS, Insert data into a table using SQL - Azure Databricks, Delta Lake Quickstart - Azure Databricks

Lakeflow Connect managed connectors are designed to simplify ingestion from supported enterprise applications and databases. They provide managed authentication, incremental processing, schema handling, and integration with Unity Catalog. Salesforce is supported as a managed application source, while SQL Server ingestion can accommodate database connectivity patterns, including privately connected or on-premises environments when the required networking is configured. Auto Loader is the appropriate service for incrementally discovering and processing new JSON files arriving in ADLS. It supports schema inference and evolution and can be used within Lakeflow Spark Declarative Pipelines. Option B would require substantial custom API and CDC code. Option D incorrectly treats cloud files as the same connector use case as Salesforce and SQL Server. Therefore, the combination in option C minimizes maintenance while matching each source with its appropriate ingestion mechanism.

================

Option C explicitly selects every required leaf field by using dot notation for nested structs. The resulting DataFrame retains event_id and event_ts while projecting device.id, device.model, device.location.latitude, and device.location.longitude as output columns. Option B expands only the immediate fields of device; the location value remains a nested struct, so the data is not fully flattened. Option A creates separate columns for the device identifier and model but retains the complete location struct instead of extracting latitude and longitude. Option D places bracket-like expressions inside column-name strings, which do not represent the required nested struct paths. Spark DataFrames support selecting nested fields through qualified column paths, making option C the direct transformation for creating analytics-friendly root-level fields.

================

A temporary view is a relational object that is defined in the metastore and points to an existing DataFrame. It does not copy or store any physical data, but only saves the query that defines the view. The lifetime of a temporary view is tied to the SparkSession that was used to create it, so it does not persist across different sessions or applications. A temporary view is useful for accessing the same data multiple times within the same notebook or session, without incurring additional storage costs. The other options are either materialized (A, E), persistent (B, C), or not relational objects ©. References: Databricks Documentation - Temporary View, Databricks Community - How do temp views actually work?, Databricks Community - What’s the difference between a Global view and a Temp view?, Big Data Programmers - Temporary View in Databricks.

Option D is directly associated with the failure because toPandas() collects the complete Spark DataFrame into a single pandas DataFrame in the driver process. With 50 million wide rows, the collected result can exceed the memory assigned to the Spark driver and produce a driver-side OutOfMemoryError. Databricks and PySpark documentation warn that toPandas() should be used only when the resulting dataset is expected to be small because all records are loaded into driver memory. spark.executor.memory controls the executor processes that perform distributed transformations, not the final local pandas object. spark.sql.shuffle.partitions controls the number of shuffle partitions, while spark.memory.fraction controls Spark execution and storage memory allocation. Therefore, the relevant configuration among the available choices is spark.driver.memory, making option D correct.

================

DataFrame.dropna() removes rows containing NULL or NaN values. Its default how= " any " behavior removes a row when any column included in the specified subset is NULL. By passing [ " customer_email " , " customer_phone " ] as the subset, the operation removes a record when either required field is missing, while ignoring NULL values in unrelated columns. Option B can produce the same filtering result, but it uses two chained where() calls and therefore does not meet the single-method-call requirement. Option C uses how= " all " and would remove a row only when all evaluated columns are NULL. Option D contains one filter() operation but requires multiple column-function calls. Consequently, option A is the direct PySpark method designed for this requirement.

================

A materialized view is appropriate because it stores the results of a defining query and refreshes them as source data changes. Expensive joins and aggregations can therefore be computed before BI users execute their queries, improving response time and providing a consistent definition of business metrics. This aligns with the Gold layer, which normally contains highly refined, aggregated, and business-oriented datasets designed for reporting and analytics. A view over raw Bronze tables would expose unvalidated source data and repeatedly execute its underlying transformations. A streaming table is more suitable for incremental data processing than for presenting precomputed business metrics. CSV files would not provide the managed table semantics, centralized definitions, or efficient query experience required. Therefore, option A best satisfies the Gold-layer requirements.

================

Cron syntax is a tool that can be used to represent and submit a complex run schedule programmatically. Cron syntax is a string of six fields that specify the frequency, date, and time of a job run. For example, the cron expression 0 0 12 * * ? means run the job at 12:00 PM every day. The data engineer can use the Databricks REST API to create or update a job with a cron schedule. The data engineer can also use the Databricks CLI to create or update a job with a cron schedule by using a JSON file that contains the cron expression. The other tools are either invalid or not suitable for representing and submitting a complex run schedule programmatically. References: Schedule a job, Jobs API, Databricks CLI, Cron expressions

 Option E is the correct answer because it is the only mandatory requirement when creating a new Delta Live Tables pipeline. A pipeline is a data processing workflow that contains materialized views and streaming tables declared in Python or SQL source files. Delta Live Tables infers the dependencies between these tables and ensures updates occur in the correct order. To create a pipeline, you need to specify at least one notebook library to be executed, which contains the Delta Live Tables syntax. You can also specify multiple libraries of different languages within your pipeline. The other options are optional or not applicable for creating a pipeline. Option A is not required, but you can optionally provide a key-value pair configuration to customize the pipeline settings, such as the storage location, the target schema, the notifications, and the pipeline mode. Option B is not applicable, as the DBU/hour cost is determined by the cluster configuration, not the pipeline creation. Option C is not required, but you can optionally specify a storage location for the output data from the pipeline. If you leave it empty, the system uses a default location. Option D is not required, but you can optionally specify a location of a target database for the written data, either in the Hive metastore or the Unity Catalog.

 Tutorial: Run your first Delta Live Tables pipeline, What is Delta Live Tables?, Create a pipeline, Pipeline configuration.