[Q47-Q69] Databricks Databricks-Certified-Professional-Data-Engineer Dumps Updated [Aug-2026] Get 100% Real Exam Questions!

Share

[Aug-2026] Pass Databricks Databricks-Certified-Professional-Data-Engineer Exam in First Attempt Guaranteed!

Full Databricks-Certified-Professional-Data-Engineer Practice Test and 217 unique questions with explanations waiting just for you, get it now!

NEW QUESTION # 47
How to determine if a table is a managed table vs external table?

  • A. Run SQL command SHOW TABLES to see the type of the table
  • B. Run IS_MANAGED('table_name') function
  • C. All managed tables are stored in unity catalog
  • D. All external tables are stored in data lake, managed tables are stored in DELTA lake
  • E. Run SQL command DESCRIBE EXTENDED table_name and check type

Answer: E

Explanation:
Explanation
The answer is Run SQL command DESCRIBE EXTENDED table_name and check type Example of External table Graphical user interface, text, application Description automatically generated

Example of managed table
Graphical user interface, text, application, Teams Description automatically generated


NEW QUESTION # 48
One of the team members Steve who has the ability to create views, created a new view called re-gional_sales_vw on the existing table called sales which is owned by John, and the second team member Kevin who works with regional sales managers wanted to query the data in region-al_sales_vw, so Steve granted the permission to Kevin using command GRANT VIEW, USAGE ON regional_sales_vw to [email protected] but Kevin is still unable to access the view?

  • A. Kevin is not the owner of the sales table
  • B. Table access control is not enabled on the table and view
  • C. Kevin needs select access on the table sales
  • D. Kevin needs owner access on the view regional_sales_vw
  • E. Steve is not the owner of the sales table

Answer: E

Explanation:
Explanation
Ownership determines whether or not you can grant privileges on derived objects to other users, since Steve is not the owner of the underlying sales table, he can not grant access to the table or data in the table indirectly.
Only owner(user or group) can grant access to a object
https://docs.microsoft.com/en-us/azure/databricks/security/access-control/table-acls/object-privileges#a-user-has Data object privileges - Azure Databricks | Microsoft Doc


NEW QUESTION # 49
A data engineering team needs to query a Delta table to extract rows that all meet the same condi-tion.
However, the team has noticed that the query is running slowly. The team has already tuned the size of the
data files. Upon investigating, the team has concluded that the rows meeting the condition are sparsely located
throughout each of the data files.
Based on the scenario, which of the following optimization techniques could speed up the query?

  • A. Write as a Parquet file
  • B. Tuning the file size
  • C. Data skipping
  • D. Bin-packing
  • E. Z-Ordering

Answer: E


NEW QUESTION # 50
The data governance team is reviewing user for deleting records for compliance with GDPR. The following logic has been implemented to propagate deleted requests from the user_lookup table to the user aggregate table.

Assuming that user_id is a unique identifying key and that all users have requested deletion have been removed from the user_lookup table, which statement describes whether successfully executing the above logic guarantees that the records to be deleted from the user_aggregates table are no longer accessible and why?

  • A. No: the change data feed only tracks inserts and updates not deleted records.
  • B. No: files containing deleted records may still be accessible with time travel until a BACUM command is used to remove invalidated data files.
  • C. No: the Delta Lake DELETE command only provides ACID guarantees when combined with the MERGE INTO command
  • D. Yes: Delta Lake ACID guarantees provide assurance that the DELETE command successed fully and permanently purged these records.

Answer: B

Explanation:
The DELETE operation in Delta Lake is ACID compliant, which means that once the operation is successful, the records are logically removed from the table. However, the underlying files that contained these records may still exist and be accessible via time travel to older versions of the table. To ensure that these records are physically removed and compliance with GDPR is maintained, a VACUUM command should be used to clean up these data files after a certain retention period. The VACUUM command will remove the files from the storage layer, and after this, the records will no longer be accessible.


NEW QUESTION # 51
Which of the following is a Continuous Probability Distributions?

  • A. Poisson probability distribution
  • B. Negative binomial distribution
  • C. Binomial probability distribution
  • D. Normal probability distribution

Answer: D


NEW QUESTION # 52
The following code has been migrated to a Databricks notebook from a legacy workload:

The code executes successfully and provides the logically correct results, however, it takes over 20 minutes to extract and load around 1 GB of data.
Which statement is a possible explanation for this behavior?

  • A. Python will always execute slower than Scala on Databricks. The run.py script should be refactored to Scala.
  • B. %sh executes shell code on the driver node. The code does not take advantage of the worker nodes or Databricks optimized Spark.
  • C. Instead of cloning, the code should use %sh pip install so that the Python code can get executed in parallel across all nodes in a cluster.
  • D. %sh triggers a cluster restart to collect and install Git. Most of the latency is related to cluster startup time.
  • E. %sh does not distribute file moving operations; the final line of code should be updated to use %fs instead.

Answer: B

Explanation:
Explanation
https://www.databricks.com/blog/2020/08/31/introducing-the-databricks-web-terminal.html The code is using %sh to execute shell code on the driver node. This means that the code is not taking advantage of the worker nodes or Databricks optimized Spark. This is why the code is taking longer to execute. A better approach would be to use Databricks libraries and APIs to read and write data from Git and DBFS, and to leverage the parallelism and performance of Spark. For example, you can use the Databricks Connect feature to run your Python code on a remote Databricks cluster, or you can use the Spark Git Connector to read data from Git repositories as Spark DataFrames.


NEW QUESTION # 53
A junior data engineer has been asked to develop a streaming data pipeline with a grouped aggregation using DataFramedf. The pipeline needs to calculate the average humidity and average temperature for each non- overlapping five-minute interval. Events are recorded once per minute per device.
Streaming DataFramedfhas the following schema:
"device_id INT, event_time TIMESTAMP, temp FLOAT, humidity FLOAT"
Code block:

Choose the response that correctly fills in the blank within the code block to complete this task.

  • A. window("event_time", "10 minutes").alias("time")
  • B. lag("event_time", "10 minutes").alias("time")
  • C. "event_time"
  • D. window("event_time", "5 minutes").alias("time")
  • E. to_interval("event_time", "5 minutes").alias("time")

Answer: D

Explanation:
This is the correct answer because the window function is used to group streaming data by time intervals. The window function takes two arguments: a time column and a window duration. The window duration specifies how long each window is, and must be a multiple of 1 second. In this case, the window duration is "5 minutes", which means each window will cover a non-overlapping five-minute interval. The window function also returns a struct column with two fields: start and end, which represent the start and end time of each window. The alias function is used to rename the struct column as "time". Verified References: [Databricks Certified Data Engineer Professional], under "Structured Streaming" section; Databricks Documentation, under "WINDOW" section.https://www.databricks.com/blog/2017/05/08/event-time-aggregation- watermarking-apache-sparks-structured-streaming.html


NEW QUESTION # 54
A data engineer wants to create a relational object by pulling data from two tables. The relational object must
be used by other data engineers in other sessions. In order to save on storage costs, the data engineer wants to
avoid copying and storing physical data.
Which of the following relational objects should the data engineer create?

  • A. View
  • B. Temporary view
  • C. Spark SQL Table
  • D. Delta Table
  • E. Database

Answer: A


NEW QUESTION # 55
A junior data engineer is working to implement logic for a Lakehouse table named silver_device_recordings. The source data contains 100 unique fields in a highly nested JSON structure.
The silver_device_recordings table will be used downstream for highly selective joins on a number of fields, and will also be leveraged by the machine learning team to filter on a handful of relevant fields, in total, 15 fields have been identified that will often be used for filter and join logic.
The data engineer is trying to determine the best approach for dealing with these nested fields before declaring the table schema.
Which of the following accurately presents information about Delta Lake and Databricks that may Impact their decision-making process?

  • A. Tungsten encoding used by Databricks is optimized for storing string data: newly-added native support for querying JSON strings means that string types are always most efficient.
  • B. By default Delta Lake collects statistics on the first 32 columns in a table; these statistics are leveraged for data skipping when executing selective queries.
  • C. Schema inference and evolution on Databricks ensure that inferred types will always accurately match the data types used by downstream systems.
  • D. Because Delta Lake uses Parquet for data storage, Dremel encoding information for nesting can be directly referenced by the Delta transaction log.

Answer: B

Explanation:
Delta Lake, built on top of Parquet, enhances query performance through data skipping, which is based on the statistics collected for each file in a table. For tables with a large number of columns, Delta Lake by default collects and stores statistics only for the first 32 columns. These statistics include min/max values and null counts, which are used to optimize query execution by skipping irrelevant data files. When dealing with highly nested JSON structures, understanding this behavior is crucial for schema design, especially when determining which fields should be flattened or prioritized in the table structure to leverage data skipping efficiently for performance optimization.
Reference: Databricks documentation on Delta Lake optimization techniques, including data skipping and statistics collection (https://docs.databricks.com/delta/optimizations/index.html).


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

  • A. Invoke an external API to validate records against the metadata rules.
  • B. Load the JSON metadata, loop through its entries, and apply expectations using dlt.expect_all.
  • C. Reference each expectation with @dlt.expect decorators in the table declaration.
  • D. Use a SQL CONSTRAINT block referencing the JSON file path.

Answer: B

Explanation:
Lakeflow Declarative Pipelines provide the expect_all method for programmatically applying multiple data quality expectations at once. The documentation explains that @dlt.expect_all accepts a dictionary of expectation names mapped to SQL constraints, allowing rules to be dynamically loaded from metadata such as JSON files. This ensures that pipelines remain maintainable and scalable without needing to hardcode individual @dlt.expect decorators. The event logs will track each expectation's pass and fail counts individually, making it auditable. Other options are incorrect: invoking an external API introduces unnecessary complexity, individual decorators require hardcoding, and SQL constraints cannot dynamically reference external JSON.


NEW QUESTION # 57
The data engineering team maintains the following code:

Assuming that this code produces logically correct results and the data in the source table has been de- duplicated and validated, which statement describes what will occur when this code is executed?

  • A. The gold_customer_lifetime_sales_summary table will be overwritten by aggregated values calculated from all records in the silver_customer_sales table as a batch job.
  • B. An incremental job will detect if new rows have been written to the silver_customer_sales table; if new rows are detected, all aggregates will be recalculated and used to overwrite the gold_customer_lifetime_sales_summary table.
  • C. An incremental job will leverage running information in the state store to update aggregate values in the gold_customer_lifetime_sales_summary table.
  • D. A batch job will update the gold_customer_lifetime_sales_summary table, replacing only those rows that have different values than the current version of the table, using customer_id as the primary key.
  • E. The silver_customer_sales table will be overwritten by aggregated values calculated from all records in the gold_customer_lifetime_sales_summary table as a batch job.

Answer: A

Explanation:
This code is using the pyspark.sql.functions library to group the silver_customer_sales table by customer_id and then aggregate the data using the minimum sale date, maximum sale total, and sum of distinct order ids.
The resulting aggregated data is then written to the gold_customer_lifetime_sales_summary table, overwriting any existing data in that table. This is a batch job that does not use any incremental or streaming logic, and does not perform any merge or update operations. Therefore, the code will overwrite the gold table with the aggregated values from the silver table every time it is executed. References :
* https://docs.databricks.com/spark/latest/dataframes-datasets/introduction-to-dataframes-python.html
* https://docs.databricks.com/spark/latest/dataframes-datasets/transforming-data-with-dataframes.html
* https://docs.databricks.com/spark/latest/dataframes-datasets/aggregating-data-with-dataframes.html


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

  • A. In the Storage Detail screen, by noting which RDDs are not stored on disk
  • B. In the Executor's log file, by gripping for "predicate push-down"
  • C. In the Query Detail screen, by interpreting the Physical Plan
  • D. In the Stage's Detail screen, in the Completed Stages table, by noting the size of data read from the Input column
  • E. In the Delta Lake transaction log. by noting the column statistics

Answer: C

Explanation:
This is the correct answer because it is where in the Spark UI one can diagnose a performance problem induced by not leveraging predicate push-down. Predicate push-down is an optimization technique that allows filtering data at the source before loading it into memory or processing it further. This can improve performance and reduce I/O costs by avoiding reading unnecessary data. To leverage predicate push-down, one should use supported data sources and formats, such as Delta Lake, Parquet, or JDBC, and use filter expressions that can be pushed down to the source. To diagnose a performance problem induced by not leveraging predicate push-down, one can use the Spark UI to access the Query Detail screen, which shows information about a SQL query executed on a Spark cluster. The Query Detail screen includes the Physical Plan, which is the actual plan executed by Spark to perform the query. The Physical Plan shows the physical operators used by Spark, such as Scan, Filter, Project, or Aggregate, and their input and output statistics, such as rows and bytes. By interpreting the Physical Plan, one can see if the filter expressions are pushed down to the source or not, and how much data is read or processed by each operator. Verified Reference: [Databricks Certified Data Engineer Professional], under "Spark Core" section; Databricks Documentation, under "Predicate pushdown" section; Databricks Documentation, under "Query detail page" section.


NEW QUESTION # 59
You are currently working to ingest millions of files that get uploaded to the cloud object storage for consumption, and you are asked to build a process to ingest this data, the schema of the file is expected to change over time, and the ingestion process should be able to handle these changes automatically. Which of the following method can be used to ingest the data incrementally?

  • A. COPY INTO
  • B. AUTO APPEND
  • C. Structured Streaming
  • D. Checkpoint
  • E. AUTO LOADER

Answer: E

Explanation:
Explanation
The answer is AUTO LOADER,
Use Auto Loader instead of the COPY INTO SQL command when:
*You want to load data from a file location that contains files in the order of millions or higher. Auto Loader can discover files more efficiently than the COPY INTO SQL command and can split file processing into multiple batches.
*COPY INTO only directory listing but AUTO LOADER supports File notification method where the Auto Loader continues to ingest files as they arrive in cloud object storage lever-aging cloud provider(Queues and triggers) and Spark's structured streaming.
*Your data schema evolves frequently. Auto Loader provides better support for schema in-ference and evolution. See Configuring schema inference and evolution in Auto Loader.


NEW QUESTION # 60
A junior developer complains that the code in their notebook isn ' t producing the correct results in the development environment. A shared screenshot reveals that while they ' re using a notebook versioned with Databricks Repos, they ' re using a personal branch that contains old logic. The desired branch named dev-
2.3.9 is not available from the branch selection dropdown.
Which approach will allow this developer to review the current logic for this notebook?

  • A. Use Repos to pull changes from the remote Git repository and select the dev-2.3.9 branch.
  • B. Use Repos to make a pull request use the Databricks REST API to update the current branch to dev-
    2.3.9
  • C. Merge all changes back to the main branch in the remote Git repository and clone the repo again
  • D. Use Repos to checkout the dev-2.3.9 branch and auto-resolve conflicts with the current branch
  • E. Use Repos to merge the current branch and the dev-2.3.9 branch, then make a pull request to sync with the remote repository

Answer: A

Explanation:
This is the correct answer because it will allow the developer to update their local repository with the latest changes from the remote repository and switch to the desired branch. Pulling changes will not affect the current branch or create any conflicts, as it will only fetch the changes and not merge them. Selecting the dev-
2.3.9 branch from the dropdown will checkout that branch and display its contents in the notebook. Verified References: [Databricks Certified Data Engineer Professional], under "Databricks Tooling" section; Databricks Documentation, under "Pull changes from a remote repository" section.


NEW QUESTION # 61
When building a DLT s pipeline you have two options to create a live tables, what is the main dif-ference between CREATE STREAMING LIVE TABLE vs CREATE LIVE TABLE?

  • A. CREATE LIVE TABLE is used in DELTA LIVE TABLES, CREATE STREAMING LIVE can only used in Structured Streaming applications
  • B. There is no difference both are the same, CREATE STRAMING LIVE will be deprecated soon
  • C. CREATE LIVE TABLE is used when working with Streaming data sources and Incremental data
  • D. CREATE STREAMING LIVE table is used in MULTI HOP Architecture
  • E. CREATE STREAMING LIVE TABLE is used when working with Streaming data sources and Incremental data

Answer: E

Explanation:
Explanation
The answer is, CREATE STREAMING LIVE TABLE is used when working with Streaming data sources and Incremental data


NEW QUESTION # 62
A table is registered with the following code:

Bothusersandordersare Delta Lake tables. Which statement describes the results of queryingrecent_orders?

  • A. All logic will execute at query time and return the result of joining the valid versions of the source tables at the time the query began.
  • B. All logic will execute when the table is defined and store the result of joining tables to the DBFS; this stored data will be returned when the table is queried.
  • C. All logic will execute at query time and return the result of joining the valid versions of the source tables at the time the query finishes.
  • D. The versions of each source table will be stored in the table transaction log; query results will be saved to DBFS with each query.
  • E. Results will be computed and cached when the table is defined; these cached results will incrementally update as new records are inserted into source tables.

Answer: B


NEW QUESTION # 63
A member of the data engineering team has submitted a short notebook that they wish to schedule as part of a larger data pipeline. Assume that the commands provided below produce the logically correct results when run as presented.

Which command should be removed from the notebook before scheduling it as a job?

  • A. Cmd 4
  • B. Cmd 5
  • C. Cmd 6
  • D. Cmd 2
  • E. Cmd 3

Answer: C

Explanation:
Cmd 6 is the command that should be removed from the notebook before scheduling it as a job. This command is selecting all the columns from the finalDF dataframe and displaying them in the notebook. This is not necessary for the job, as the finalDF dataframe is already written to a table in Cmd 7. Displaying the dataframe in the notebook will only consume resources and time, and it will not affect the output of the job.
Therefore, Cmd 6 is redundant and should be removed.
The other commands are essential for the job, as they perform the following tasks:
* Cmd 1: Reads the raw_data table into a Spark dataframe called rawDF.
* Cmd 2: Prints the schema of the rawDF dataframe, which is useful for debugging and understanding the data structure.
* Cmd 3: Selects all the columns from the rawDF dataframe, as well as the nested columns from the values struct column, and creates a new dataframe called flattenedDF.
* Cmd 4: Drops the values column from the flattenedDF dataframe, as it is no longer needed after flattening, and creates a new dataframe called finalDF.
* Cmd 5: Explains the physical plan of the finalDF dataframe, which is useful for optimizing and tuning the performance of the job.
* Cmd 7: Writes the finalDF dataframe to a table called flat_data, using the append mode to add new data to the existing table.


NEW QUESTION # 64
The data engineer team is configuring environment for development testing, and production before beginning migration on a new data pipeline. The team requires extensive testing on both the code and data resulting from code execution, and the team want to develop and test against similar production data as possible.
A junior data engineer suggests that production data can be mounted to the development testing environments, allowing pre production code to execute against production data. Because all users have Admin privileges in the development environment, the junior data engineer has offered to configure permissions and mount this data for the team.
Which statement captures best practices for this situation?

  • A. Because delta Lake versions all data and supports time travel, it is not possible for user error or malicious actors to permanently delete production data, as such it is generally safe to mount production data anywhere.
  • B. All developer, testing and production code and data should exist in a single unified workspace; creating separate environments for testing and development further reduces risks.
  • C. In environments where interactive code will be executed, production data should only be accessible with read permissions; creating isolated databases for each environment further reduces risks.
  • D. Because access to production data will always be verified using passthrough credentials it is safe to mount data to any Databricks development environment.

Answer: C

Explanation:
The best practice in such scenarios is to ensure that production data is handled securely and with proper access controls. By granting only read access to production data in development and testing environments, it mitigates the risk of unintended data modification. Additionally, maintaining isolated databases for different environments helps to avoid accidental impacts on production data and systems.
References:
* Databricks best practices for securing data: https://docs.databricks.com/security/index.html


NEW QUESTION # 65
The data engineering team maintains a table of aggregate statistics through batch nightly updates. This includes total sales for the previous day alongside totals and averages for a variety of time periods including the 7 previous days, year-to-date, and quarter-to-date. This table is namedstore_saies_summaryand the schema is as follows:

The tabledaily_store_salescontains all the information needed to updatestore_sales_summary. The schema for this table is:
store_id INT, sales_date DATE, total_sales FLOAT
Ifdaily_store_salesis implemented as a Type 1 table and thetotal_salescolumn might be adjusted after manual data auditing, which approach is the safest to generate accurate reports in thestore_sales_summary table?

  • A. Implement the appropriate aggregate logic as a batch read against the daily_store_sales table and use upsert logic to update results in the store_sales_summary table.
  • B. Implement the appropriate aggregate logic as a Structured Streaming read against the daily_store_sales table and use upsert logic to update results in the store_sales_summary table.
  • C. Use Structured Streaming to subscribe to the change data feed for daily_store_sales and apply changes to the aggregates in the store_sales_summary table with each update.
  • D. Implement the appropriate aggregate logic as a batch read against the daily_store_sales table and overwrite the store_sales_summary table with each Update.
  • E. Implement the appropriate aggregate logic as a batch read against the daily_store_sales table and append new rows nightly to the store_sales_summary table.

Answer: C

Explanation:
The daily_store_sales table contains all the information needed to update store_sales_summary. The schema of the table is:
store_id INT, sales_date DATE, total_sales FLOAT
The daily_store_sales table is implemented as a Type 1 table, which means that old values are overwritten by new values and no history is maintained. The total_sales column might be adjusted after manual data auditing, which means that the data in the table may change over time.
The safest approach to generate accurate reports in the store_sales_summary table is to use Structured Streaming to subscribe to the change data feed for daily_store_sales and apply changes to the aggregates in the store_sales_summary table with each update. Structured Streaming is a scalable and fault-tolerant stream processing engine built on Spark SQL. Structured Streaming allows processing data streams as if they were tables or DataFrames, using familiar operations such as select, filter, groupBy, or join. Structured Streaming also supports output modes that specify how to write the results of a streaming query to a sink, such as append, update, or complete. Structured Streaming can handle both streaming and batch data sources in a unified manner.
The change data feed is a feature of Delta Lake that provides structured streaming sources that can subscribe to changes made to a Delta Lake table. The change data feed captures both data changes and schema changes as ordered events that can be processed by downstream applications or services. The change data feed can be configured with different options, such as starting from a specific version or timestamp, filtering by operation type or partition values, or excluding no-op changes.
By using Structured Streaming to subscribe to the change data feed for daily_store_sales, one can capture and process any changes made to the total_sales column due to manual data auditing. By applying these changes to the aggregates in the store_sales_summary table with each update, one can ensure that the reports are always consistent and accurate with the latest data. Verified References: [Databricks Certified Data Engineer Professional], under "Spark Core" section; Databricks Documentation, under "Structured Streaming" section; Databricks Documentation, under "Delta Change Data Feed" section.


NEW QUESTION # 66
You have accidentally deleted records from a table called transactions, what is the easiest way to restore the records deleted or the previous state of the table? Prior to deleting the version of the table is 3 and after delete the version of the table is 4.

  • A. RESTORE TABLE transactions TO VERSION as of 3
    C .
    1.INSERT INTO OVERWRITE transactions
    2.SELECT * FROM transactions VERSION AS OF 3
    3.MINUS
    4.SELECT * FROM transactions
  • B. COPY OVERWRITE transactions from VERSION as of 3
  • C. 1.INSERT INTO OVERWRITE transactions
    2.SELECT * FROM transactions VERSION AS OF 4
    3.INTERSECT
    4.SELECT * FROM transactions
  • D. RESTORE TABLE transactions FROM VERSION as of 4

Answer: A

Explanation:
Explanation
RESTORE (Databricks SQL) | Databricks on AWS
1.RESTORE [TABLE] table_name [TO] time_travel_version
Time travel supports using timestamp or version number
1.time_travel_version
2. { TIMESTAMP AS OF timestamp_expression |
3. VERSION AS OF version }
*timestamp_expression can be any one of:
*'2018-10-18T22:15:12.013Z', that is, a string that can be cast to a timestamp
*cast('2018-10-18 13:36:32 CEST' as timestamp)
*'2018-10-18', that is, a date string
*current_timestamp() - interval 12 hours
*date_sub(current_date(), 1)
*Any other expression that is or can be cast to a timestamp


NEW QUESTION # 67
A data engineer has created a new cluster using shared access mode with default configurations. The data engineer needs to allow the development team access to view the driver logs if needed.
What are the minimal cluster permissions that allow the development team to accomplish this?

  • A. CAN ATTACH TO
  • B. CAN MANAGE
  • C. CAN VIEW
  • D. CAN RESTART

Answer: C

Explanation:
Databricks provides different permission levels to control access to clusters. The correct minimal permission required for viewing driver logs is CAN VIEW.
Databricks Cluster Permission Levels:
CAN ATTACH TO:
Allows users to attach notebooks to a cluster but does not allow them to view logs.
Not sufficient for viewing driver logs.
CAN MANAGE:
Grants full control over the cluster, including starting, stopping, and editing configurations.
Too broad for this requirement.
CAN VIEW (Correct Answer):
Allows users to view cluster details, logs, and status but not modify any configurations.
Minimal required permission for viewing logs.
CAN RESTART:
Grants permission to restart the cluster, but does not include log access.
Not sufficient for viewing logs.
Conclusion:
The minimal permission needed to allow the development team to view driver logs is CAN VIEW.
Reference:
Databricks Cluster Permissions Documentation


NEW QUESTION # 68
The business intelligence team has a dashboard configured to track various summary metrics for retail stories. This includes total sales for the previous day alongside totals and averages for a variety of time periods. The fields required to populate this dashboard have the following schema:

For Demand forecasting, the Lakehouse contains a validated table of all itemized sales updated incrementally in near real-time. This table named products_per_order, includes the following fields:

Because reporting on long-term sales trends is less volatile, analysts using the new dashboard only require data to be refreshed once daily. Because the dashboard will be queried interactively by many users throughout a normal business day, it should return results quickly and reduce total compute associated with each materialization.
Which solution meets the expectations of the end users while controlling and limiting possible costs?

  • A. Populate the dashboard by configuring a nightly batch job to save the required to quickly update the dashboard with each query.
  • B. Use Structure Streaming to configure a live dashboard against the products_per_order table within a Databricks notebook.
  • C. Use the Delta Cache to persists the products_per_order table in memory to quickly the dashboard with each query.
  • D. Define a view against the products_per_order table and define the dashboard against this view.

Answer: D

Explanation:
Given the requirement for daily refresh of data and the need to ensure quick response times for interactive queries while controlling costs, a nightly batch job to pre-compute and save the required summary metrics is the most suitable approach.
By pre-aggregating data during off-peak hours, the dashboard can serve queries quickly without requiring on-the-fly computation, which can be resource-intensive and slow, especially with many users.
This approach also limits the cost by avoiding continuous computation throughout the day and instead leverages a batch process that efficiently computes and stores the necessary data.
The other options (A, C, D) either do not address the cost and performance requirements effectively or are not suitable for the use case of less frequent data refresh and high interactivity.
Reference:
Databricks Documentation on Batch Processing: Databricks Batch Processing Data Lakehouse Patterns: Data Lakehouse Best Practices


NEW QUESTION # 69
......

Get Latest Databricks-Certified-Professional-Data-Engineer Dumps Exam Questions in here: https://passking.actualtorrent.com/Databricks-Certified-Professional-Data-Engineer-exam-guide-torrent.html