Free and Premium Databricks Databricks-Certified-Data-Engineer-Associate Dumps Questions Answers

 Delta Live Tables expectations are optional clauses that apply data quality checks on each record passing through a query. An expectation consists of a description, a boolean statement, and an action to take when a record fails the expectation. The ON VIOLATION clause specifies the action to take, which can be one of the following: warn, drop, or fail. The drop action means that invalid records are dropped from the target dataset before data is written to the target. The failure is reported as a metric for the dataset, which can be viewed by querying the Delta Live Tables event log. The event log contains information such as the number of records that violate an expectation, the number of records dropped, and the number of records written to the target dataset. References:

Manage data quality with Delta Live Tables

Monitor Delta Live Tables pipelines

Delta Live Tables SQL language reference

Delta Live Tables is a tool that enables data engineers to build and manage reliable data pipelines with minimal code. One of the features of Delta Live Tables is data quality monitoring, which allows data engineers to define quality expectations for their data and automatically check them at every step of the pipeline. Data quality monitoring can help detect and resolve data quality issues, such as missing values, duplicates, outliers, or schema changes. Data quality monitoring can also generate alerts and reports on the quality level of the data, and enable data engineers to troubleshoot and fix problems quickly. References: Delta Live Tables Overview, Data Quality Monitoring

 A data lakehouse is a new paradigm that can be used to simplify and unify siloed data architectures that are specialized for specific use cases. A data lakehouse combines the best of both data lakes and data warehouses, providing a single platform that supports diverse data types, open standards, low-cost storage, high-performance queries, ACID transactions, schema enforcement, and governance. A data lakehouse enables data engineers to build reliable and scalable data pipelines that can serve various downstream applications and users, such as data science, machine learning, analytics, and reporting. A data lakehouse leverages the power of Delta Lake, a storage layer that brings reliability and performance to data lakes. References: What is a data lakehouse?, Delta Lake, Lakehouse: A New Generation of Open Platforms that Unify Data Warehousing and Advanced Analytics

The workspace administrator is the only individual who can transfer ownership of the Delta tables in Data Explorer, assuming the original data engineer no longer has access. The workspace administrator has the highest level of permissions in the workspace and can manage all resources, users, and groups. The other options are either not possible or not sufficient to perform the ownership transfer. The Databricks account representative is not involved in the workspace management. The transfer is possible and not dependent on the original data engineer. The new lead data engineer may not have the necessary permissions to access or modify the Delta tables, unless granted by the workspace administrator or the original data engineer before leaving. References: Workspace access control, Manage Unity Catalog object ownership.

A data lakehouse is a data management architecture that combines the flexibility, cost-efficiency, and scale of data lakes with the data management and ACID transactions of data warehouses, enabling business intelligence (BI) and machine learning (ML) on all data12. One of the key features of a data lakehouse is that it supports ACID-compliant transactions, which means that it ensures data integrity, consistency, and isolation across concurrent read and write operations3. This feature results in improved data quality over a traditional data lake, which does not support transactions and may suffer from data corruption, duplication, or inconsistency due to concurrent or streaming data ingestion and processing . References: 1: What is a Data Lakehouse? - Databricks 2: What is a Data Lakehouse? Definition, features & benefits. - Qlik 3: ACID Transactions - Databricks : [Data Lake vs Data Warehouse: Key Differences] : [Data Lakehouse: The Future of Data Engineering]

The COPY INTO statement is an idempotent operation, which means that it will skip any files that have already been loaded into the target table1. This ensures that the data is not duplicated or corrupted by multiple attempts to load the same file. Therefore, if the data engineer runs the same command every day without specifying the names of the files to be copied with the FILES keyword or a glob pattern with the PATTERN keyword, the statement will only copy the first file that matches the source location and ignore the rest. To avoid this problem, the data engineer should either use the FILES or PATTERN keywords to filter the files to be copied based on the date or some other criteria, or delete the files from the source location after they are copied into the table2. References: 1: COPY INTO | Databricks on AWS 2: Get started using COPY INTO to load data | Databricks on AWS

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.

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

The small country lookup DataFrame should be broadcast to the executors. A broadcast join copies the small side of the join to each worker, allowing every executor to join its partition of the billion-row events DataFrame locally. This avoids shuffling the very large DataFrame across the network and is effective when one relation is small enough to fit comfortably in executor memory. Broadcasting events_df would be impractical because it contains billions of rows. Caching or persisting both DataFrames can help when data is reused, but neither action by itself changes the join strategy or removes the expensive shuffle. Databricks exposes the PySpark broadcast function specifically to mark a DataFrame as suitable for a broadcast join. Therefore, option D is the correct optimization.

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

The data engineering team can use the spark.table method to access the Delta table sales in PySpark. This method returns a DataFrame representation of the Delta table, which can be used for further processing or testing. The spark.table method works for any table that is registered in the Hive metastore or the Spark catalog, regardless of the file format1. Alternatively, the data engineering team can also use the DeltaTable.forPath method to load the Delta table from its path2. References: 1: SparkSession | PySpark 3.2.0 documentation 2: Welcome to Delta Lake’s Python documentation page — delta-spark 2.4.0 documentation

Delta Sharing is an open protocol developed by Databricks that enables secure, real-time sharing of data across organizations without requiring recipients to have a Databricks account. It is specifically designed for scenarios where external partners need read-only access to data stored in Delta format. With Delta Sharing, data providers create a share and grant access to recipients via a secure mechanism (such as a profile file or URL-based access), ensuring that the data cannot be modified by the consumer. This approach eliminates the need for data duplication or manual file transfers, maintaining data freshness and governance. Option B is incorrect because Unity Catalog governs internal access within an organization, not external sharing without accounts. Option C is inefficient and breaks data lineage and freshness. Option D violates security best practices by granting excessive permissions. Delta Sharing ensures fine- grained access control, auditability, and secure external collaboration , making it the correct solution for this requirement.

=========

Databricks documents that Delta Sharing does not require data replication , but cloud providers can still charge data egress fees when data is shared across clouds or across geographic regions . Databricks specifically states that sharing within the same region incurs no egress cost , while cross-cloud or cross-region transfers can create additional charges from the underlying cloud provider. That means option A is correct. Options B and C describe same-cloud or same-region use cases that do not trigger the cross-region/cross-cloud egress pattern Databricks calls out. Option D is unrelated to the main documented billing driver for Delta Sharing costs. The important principle is that Delta Sharing itself is designed to avoid replication overhead, but the physical movement of data between cloud boundaries or regions can still result in vendor networking charges. Therefore, when sharing data with external partners in other regions or clouds, engineers should plan for possible egress costs and monitor them accordingly.

=========

Databricks Asset Bundles use YAML configuration, and Databricks documentation specifies that bundle configuration is expressed in a root databricks.yml file. The resources mapping is used to define supported objects such as jobs , and job definitions include keys like name and tasks. Tasks in a job are defined under the tasks key, and a notebook task is represented with notebook_task and notebook_path. Option A is the only answer written in the correct general YAML bundle structure and matches the documented style of defining bundle resources. Options B and C use JSON- and Python-style syntax rather than bundle YAML. Option D uses Terraform/HCL-style syntax, which is not the Databricks Asset Bundle format. While a full production bundle often includes more top-level settings such as bundle, targets, or workspace, the question asks which format is valid, and only option A matches the documented Databricks Asset Bundles configuration model.

=========

Option D matches the heterogeneous sources and governance requirements. A relational database, object storage, and Kafka require source-appropriate ingestion configurations rather than a single connector attempting to handle every source. Database ingestion can use incremental or change-data-capture processing, Amazon S3 files can use file-oriented ingestion, and Kafka requires a streaming connector. Publishing the outputs into Unity Catalog schemas provides centralized permissions, discovery, and governance boundaries. Supported Databricks ingestion workloads also record lineage between source and destination objects in Unity Catalog. Delta table history and time travel provide access to earlier table versions when the required transaction-log and data-file retention settings are maintained. Disabling version history or repeatedly performing complete reloads would weaken auditability and increase processing overhead. Therefore, the separate, incrementally processed, Unity Catalog-governed design in option D is correct.

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

databricks bundle validate should be run first because it checks whether the bundle configuration files are syntactically valid and reports configuration warnings. After validation succeeds, databricks bundle deploy creates or updates the bundle-defined resources and uploads the required artifacts to the selected workspace target. The final command, databricks bundle run, starts a deployed job or Lakeflow pipeline by using its resource key. bundle init creates a new project from a template and is not the validation step for an already developed bundle. bundle sync synchronizes files for development workflows but does not replace a complete deployment. The commands bundle execute, bundle check, bundle upload, and bundle start are not the appropriate command sequence. Therefore, option B is correct.

To include a property indicating that a table contains personally identifiable information (PII), the TBLPROPERTIES keyword is used in SQL to add metadata to a table. The correct syntax to define a table property for PII is as follows:

CREATE TABLE customersInFrance

USING DELTA

TBLPROPERTIES ( ' PII ' = ' true ' )

AS

SELECT id,

firstName,

lastName

FROM customerLocations

WHERE country = ' FRANCE ' ;

The TBLPROPERTIES ( ' PII ' = ' true ' ) line correctly sets a table property that tags the table as containing personally identifiable information. This is in accordance with organizational policies for handling sensitive information.

Option D retains only orders whose customer identifier matches a row in customers_df. Because customers_df contains only active customers, an inner join acts as a membership filter: orders belonging to active customers match and remain, while orders belonging to inactive customers have no corresponding row and are removed. A left join with orders_df on the left would preserve every order, including orders from inactive customers, unless an additional NULL filter were applied. A left join with customers_df on the left changes the driving dataset and can exclude the required order structure or produce different cardinality. A cross join generates the Cartesian product of both DataFrames and is unrelated to key-based filtering. Therefore, the inner join in option D precisely implements the stated active-customer filtering requirement.

 A serverless SQL endpoint is a compute resource that is automatically managed by Databricks and scales up or down based on the workload. A serverless SQL endpoint can be used to run queries and dashboards without requiring manual configuration or management. A serverless SQL endpoint is only active when it is needed and shuts down automatically when idle, minimizing the total running time and cost. A serverless SQL endpoint can be created and assigned to a dashboard using the Databricks SQL UI or the SQL Analytics API. References:

Create a serverless SQL endpoint

Assign a SQL endpoint to a dashboard

SQL Analytics API

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.

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

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.

In Production mode, the pipeline runs continuously and updates the output tables whenever new data is available in the input sources. The compute resources are allocated on demand and released when the pipeline is stopped. This mode is suitable for production workloads that require high availability and reliability. References: Configure pipeline settings for Delta Live Tables, Tutorial: Run your first Delta Live Tables pipeline, Building Reliable Data Pipelines Using DataBricks’ Delta Live Tables

The metrics indicate data skew because one task is taking substantially longer than most tasks in the stage. Databricks advises checking the maximum task duration against the 75th-percentile duration: when the maximum is at least 50% higher, the stage may be skewed. Here, the 75th percentile is 50 seconds and the maximum is 80 seconds, so the maximum is 60% higher. The 25th percentile, median, and 75th percentile are tightly grouped between 40 and 50 seconds, while the maximum is a clear outlier. That pattern means a small number of tasks are processing disproportionately expensive partitions. These values alone do not prove cluster under-provisioning or excessive garbage collection; those diagnoses require resource, executor, spill, and GC metrics. Therefore, option A is correct.

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

The OPTIMIZE command in Delta Lake is designed to compact small files into larger files to improve query performance and reduce file system overhead. Importantly, OPTIMIZE is considered an idempotent operation when run on unchanged data. This means that once files have been compacted optimally, running OPTIMIZE again does not produce additional changes unless new small files have been added to the table. Databricks ensures that file compaction is efficient and avoids unnecessary rewrites, which helps control compute costs and maintain stable performance. While features like ZORDER can be applied during OPTIMIZE to improve data skipping, re-running the same command without new data will not further reorganize files. Options A, B, and C incorrectly imply additional restructuring or changes on repeated execution. According to Delta Lake best practices, OPTIMIZE should be run periodically after data ingestion events rather than repeatedly on unchanged datasets. This behavior reinforces predictable performance and efficient resource utilization in Databricks environments.

=========

 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

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.

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

 To return the number of null values in the member_id column, the best option is to use the count_if function, which counts the number of rows that satisfy a given condition. In this case, the condition is that the member_id column is null. The other options are either incorrect or not supported by Spark SQL. Option A will return the number of non-null values in the member_id column. Option B will not work because there is no count_null function in Spark SQL. Option D will not work because there is no null function in Spark SQL. Option E will not work because there is no count_null function in Spark SQL. References:

Built-in Functions - Spark SQL, Built-in Functions

count_if - Spark SQL, Built-in Functions

The reason why all of the data files and metadata files were deleted from the file system after dropping the table is that the table was managed. A managed table is a table that is created and managed by Spark SQL. It stores both the data and the metadata in the default location specified by the spark.sql.warehouse.dir configuration property. When a managed table is dropped, both the data and the metadata are deleted from the file system.

Option B is not correct, as the size of the table’s data does not affect the behavior of dropping the table. Whether the table’s data is smaller or larger than 10 GB, the data files and metadata files will be deleted if the table is managed, and will be preserved if the table is external.

Option C is not correct, for the same reason as option B.

Option D is not correct, as an external table is a table that is created and managed by the user. It stores the data in a user-specified location, and only stores the metadata in the Spark SQL catalog. When an external table is dropped, only the metadata is deleted from the catalog, but the data files are preserved in the file system.

Option E is not correct, as a table must have a location to store the data. If the location is not specified by the user, it will use the default location for managed tables. Therefore, a table without a location is a managed table, and dropping it will delete both the data and the metadata.

Managing Tables

[Databricks Data Engineer Professional Exam Guide]

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]

 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.

Option D satisfies the requirements because a Lakeflow Connect managed SaaS connector provides source-specific authentication, incremental ingestion, schema evolution, and automated retries as managed capabilities. Managed connectors use serverless infrastructure and publish governed destination tables that can be processed downstream with Lakeflow Spark Declarative Pipelines. This avoids custom code for OAuth token handling, API pagination, CDC state management, retry behavior, and schema-change recovery. Option A still requires the engineering team to implement and maintain CDC and operational logic. Options B and C place most authentication, schema evolution, change tracking, and failure recovery responsibilities in custom notebooks or jobs, conflicting with the minimal-maintenance requirement. Therefore, the fully managed connector described in option D is the only solution that delivers the requested ingestion and operational behavior as an integrated platform capability.

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

The --target prod option explicitly selects the prod target from the bundle configuration. Databricks then resolves ${var.dataset_catalog} using the target-level value catalog_prod, which takes precedence over the top-level default of catalog_dev. This allows the same dashboard resource definition to be promoted across environments without editing the resource itself. The --var option can override an individual variable, but it does not automatically select the production target. The --profile option selects an authentication profile from .databrickscfg; it does not select a bundle target or automatically apply the target’s variables. bundle execute is not the deployment command. Consequently, option D correctly combines production-target selection with the environment-specific variable override already defined in the YAML configuration.

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

To minimize the total running time of the SQL endpoint used in the refresh schedule of a dashboard in Databricks, the most effective approach is to utilize the Auto Stop feature. This feature allows the SQL endpoint to automatically stop after a period of inactivity, ensuring that it only runs when necessary, such as during the dashboard refresh or when actively queried. This minimizes resource usage and associated costs by ensuring the SQL endpoint is not running idle outside of these operations.

Auto Loader is a tool that can incrementally and efficiently process new data files as they arrive in cloud storage without any additional setup. Auto Loader provides a Structured Streaming source called cloudFiles, which automatically detects and processes new files in a given input directory path on the cloud file storage. Auto Loader also tracks the ingestion progress and ensures exactly-once semantics when writing data into Delta Lake. Auto Loader can ingest various file formats, such as JSON, CSV, XML, PARQUET, AVRO, ORC, TEXT, and BINARYFILE. Auto Loader has support for both Python and SQL in Delta Live Tables, which are a declarative way to build production-quality data pipelines with Databricks. References: What is Auto Loader?, Get started with Databricks Auto Loader, Auto Loader in Delta Live Tables

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.

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.

Serverless compute for workflows is designed to minimize operational overhead for Databricks Jobs while enforcing Unity Catalog governance. When a job is configured to run on serverless compute (in supported regions), Databricks automatically selects instance types , manages autoscaling , enables Photon where applicable, and handles runtime upgrades without user intervention. This directly satisfies the requirement to reduce operational toil. All-purpose clusters (option B) and traditional job clusters (option C) still require users to manage cluster sizing, instance families, and runtime versions, which contradicts the goal of automation. SQL warehouses (option A) are intended for SQL workloads and do not support running general Python notebook job tasks as workflow steps. Databricks documentation specifies that serverless workflows are compatible with Unity Catalog and are the recommended approach when users want fully managed compute for scheduled pipelines and tasks, provided the workspace is in a supported region. This makes serverless compute the correct and fully compliant solution.

In Unity Catalog, an external table is defined by referencing data that already exists in cloud storage, and Databricks documentation states that this is done by using a LOCATION clause that points to the storage path. Databricks also notes that the external table’s path should be contained within an existing external location that has been configured with the appropriate storage credential and access permissions. This makes option A the correct choice. Option B is incorrect because simply calling something “unmanaged” without specifying a location does not create a proper Unity Catalog external table. Option C is also incorrect because Databricks documentation explicitly requires a storage location for Unity Catalog external tables. Option D is wrong because managed tables are intended for Databricks-managed storage and lifecycle handling, not for referencing existing external files. So, for ADLS-based data that must remain in place while still being queryable through Databricks, the right pattern is to configure the external location and then create the table with a CREATE TABLE ... LOCATION statement.

=========

A Gold table is a table that contains highly refined and aggregated data that powers analytics, machine learning, and production applications. It represents data that has been transformed into knowledge, rather than just information. A Gold table is typically the final output of a medallion lakehouse architecture, where data flows from Bronze to Silver to Gold tables, with each layer improving the structure and quality of data. A job that queries aggregated data designed to feed into a dashboard is an example of a data workload that will utilize a Gold table as its source, as it requires data that is ready for consumption and analysis. The other options are either data workloads that will use a Bronze or Silver table as their source, or data workloads that will produce a Gold table as their output. References: Databricks Documentation - What is the medallion lakehouse architecture?, Databricks Documentation - What is a Medallion Architecture?, K21Academy - Delta Lake Architecture & Azure Databricks Workspace.

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.

=========

 In Databricks SQL, you can use scheduled query executions to update your dashboards or enable routine alerts. By default, your queries do not have a schedule. To set the schedule, you can use the dropdown pickers to specify the frequency, period, starting time, and time zone. You can also choose to end the schedule on a certain date by selecting the End date checkbox and picking a date from the calendar. This way, you can ensure that the query does not run beyond the first week of the project’s release and does not incur any additional cost. Option A is incorrect, as setting a limit to the number of DBUs does not stop the query from running. Option B is incorrect, as there is no option to end the schedule after a certain number of refreshes. Option C is incorrect, as there is a way to ensure the query does not cost the organization money beyond the first week of the project’s release. Option D is incorrect, as setting a limit to the number of individuals who can manage the query’s refresh schedule does not affect the query’s execution or cost. References: Schedule a query, Schedule a query - Azure Databricks - Databricks SQL

he approach that can be used to identify the owner of new_table is to review the Owner field in the table’s page in Data Explorer. Data Explorer is a web-based interface that allows users to browse, create, and manage data objects such as tables, views, and functions in Databricks1. The table’s page in Data Explorer provides various information about the table, such as its schema, partitions, statistics, history, and permissions2. The Owner field shows the name and email address of the user who created or owns the table3. The data engineer can use this information to contact the table owner and request for permission to access the table.

The other options are not correct or reliable for identifying the owner of new_table. Reviewing the Permissions tab in the table’s page in Data Explorer can show the users and groups who have access to the table, but not necessarily the owner4. Reviewing the Owner field in the table’s page in the cloud storage solution can be misleading, as the owner of the data files may not be the same as the owner of the table5. There is a way to identify the owner of the table, as explained above, so option E is false.

1: Data Explorer | Databricks on AWS

2: Table details | Databricks on AWS

3: Set owner when creating a view in databricks sql - Databricks - 9978

4: Table access control | Databricks on AWS

5: External tables | Databricks on AWS

Option B reads the relational source through JDBC and writes the resulting Spark DataFrame directly as a registered Unity Catalog table using its three-level name: catalog, schema, and table. Once written with saveAsTable, the data is immediately discoverable and queryable through Databricks SQL, subject to Unity Catalog permissions. Because the read and write operations occur through supported Databricks workloads, Unity Catalog can capture lineage between the source operation, notebook or job, and destination table. Writing files only to DBFS or an external path does not by itself create the required governed table. Introducing a separate staging and loading job adds unnecessary processing and operational complexity. A Pandas extraction also reduces scalability and does not satisfy the direct managed-table requirement. Therefore, option B is correct.

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

In the Medallion Architecture promoted by Databricks, the Bronze layer represents the raw ingestion layer where data is stored in its original form with minimal transformation. The primary goal is to ensure data fidelity and traceability , not to apply business logic or heavy transformations. Typical operations in the Bronze layer include schema inference (or enforcement), ingestion of raw data, and the addition of metadata columns such as ingestion timestamp, load date/time, and process identifiers. These metadata fields help track lineage, enable debugging, and support incremental processing downstream. Extensive data cleansing (A), aggregations (B), and business transformations (C) are intentionally deferred to the Silver and Gold layers , where data is refined and structured for analytics. By keeping Bronze data close to the source and append-only, organizations maintain a reliable audit trail and can reprocess data if needed. Therefore, adding operational metadata like load timestamps and process IDs is the correct characteristic of Bronze layer transformations.

=========

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.

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

The correct command to create a new table that contains all records from two tables without duplicate records is to use the UNION operator. The UNION operator combines the results of two queries and removes any duplicate rows. The INNER JOIN, OUTER JOIN, and MERGE operators do not remove duplicate rows, and the INTERSECT operator only returns the rows that are common to both tables. Therefore, option B is the only correct answer. References: Databricks SQL Reference - UNION, Databricks SQL Reference - JOIN, Databricks SQL Reference - MERGE, [Databricks SQL Reference - INTERSECT]

The STREAM function is used to process data from a streaming live table or view, which is a table or view that contains data that has been added only since the last pipeline update. Streaming live tables and views are stateful, meaning that they retain the state of the previous pipeline run and only process new data based on the current query. This is useful for incremental processing of streaming or batch data sources. The customers table in the query is a streaming live table, which means that it contains the latest data from the source. The STREAM function enables the query to read the data from the customers table incrementally and create another streaming live table named loyal_customers, which contains the customer IDs of the customers with high loyalty level. References: Difference between LIVE TABLE and STREAMING LIVE TABLE, CREATE STREAMING TABLE, Load data using streaming tables in Databricks SQL.

The MERGE command can be used to upsert data from a source table, view, or DataFrame into a target Delta table. It allows you to specify conditions for matching and updating existing records, and inserting new records when no match is found. This way, you can avoid writing duplicate records into a Delta table1. The other commands (DROP, IGNORE, APPEND, INSERT) do not have this functionality and may result in duplicate records or data loss234. References: 1: Upsert into a Delta Lake table using merge | Databricks on AWS 2: SQL DELETE | Databricks on AWS 3: SQL INSERT INTO | Databricks on AWS 4: SQL UPDATE | Databricks on AWS

Databricks recommends managed tables when you want the platform to control both the table metadata and the underlying storage lifecycle. For Unity Catalog managed tables, Databricks manages storage layout and applies platform-managed optimization features over time. Databricks also documents that when you drop a managed table , the underlying cloud data is deleted automatically after the managed retention period, which simplifies cleanup and reduces storage administration. That behavior matches the requirement exactly. External tables, by contrast, are used when you want to retain direct control over the storage path and lifecycle. Databricks explicitly states that dropping an external table removes only the metadata and does not delete the underlying files . Foreign tables are for federation scenarios against external systems, not for Bronze ingestion storage managed by Databricks. Temporary views also do not provide the desired governed lifecycle. Because the team wants Databricks-managed storage, managed retention, and simplified lifecycle handling, managed tables are the correct choice for these Bronze ingestion tables.

=========

 To grant full permissions on a database to a user, group, or service principal, the GRANT ALL PRIVILEGES ON DATABASE command can be used. This command grants all the applicable privileges on the database, such as CREATE, SELECT, MODIFY, and USAGE. The other options are either incorrect or incomplete, as they do not grant all the privileges or specify the wrong database or principal. References:

GRANT

Privileges

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

For small-scale, ad hoc Python workloads that run frequently and should start quickly and stop without leaving idle infrastructure running, serverless compute is the best fit. Databricks documentation explains that serverless compute allows users to run workloads without provisioning compute resources manually , and Databricks automatically allocates and manages the required resources. This improves startup and scaling speed and minimizes idle time, which directly matches the requirement that compute should “wind down quickly” after the work completes. Databricks also recommends serverless compute broadly when the workload is supported because it is the simplest and most reliable option. An all-purpose cluster is better suited to interactive collaborative development and can remain running longer than needed. A job cluster is ephemeral and often a good batch choice, but it still requires more explicit configuration than serverless and is not as optimized for minimal operational overhead. A SQL warehouse is intended for SQL workloads, not general ad hoc Python script execution. Therefore, serverless compute is the most appropriate choice.

When migrating to Delta Live Tables (DLT) with a data pipeline that involves different programming languages across various data layers, the migration does not require unifying the pipeline into a single language. Delta Live Tables support multi-language pipelines, allowing data engineers and data analysts to work in their preferred languages, such as Python for data engineering tasks (raw, bronze, and silver layers) and SQL for data analytics tasks (gold layer). This capability is particularly beneficial in collaborative settings and leverages the strengths of each language for different stages of data processing.

Option B preserves the historical evidence needed to diagnose the regression. The Lakeflow Jobs UI provides run history, duration information, task details, links to the compute resource, and task metrics. Comparing several slow and normal runs shows whether the increase is consistent or intermittent. Cluster metrics such as CPU utilization, memory pressure, disk I/O, and network activity can then reveal resource spikes or bottlenecks that correlate with the longer runs. Automatically increasing cluster size before diagnosis could hide the cause and increase cost. Archiving old runs or resetting a baseline removes useful comparison data. Rerunning the job once does not make seven days of historical information irrelevant and cannot establish a trustworthy new baseline. Therefore, comparing run-history and cluster metrics, as stated in option B, is the appropriate troubleshooting action.

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

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?