Free DP-750 practice test

In Unity Catalog, dropping a managed table removes both the table metadata from the metastore and permanently deletes the underlying data files from the managed storage location. This is the defining characteristic of managed tables — Unity Catalog owns the data lifecycle, so dropping the table also drops the data. — Unity Catalog does not automatically retain managed table data files for 30 days after a DROP TABLE; the deletion is immediate. (Note: Delta table time travel and the underlying Delta log may retain data briefly depending on VACUUM settings, but the table registration and managed ownership are removed.) — There is no restriction preventing managed tables from being dropped; any user with the DROP TABLE privilege can drop a managed table. — While Databricks has introduced some protections for accidental deletion in certain contexts, a standard DROP TABLE on a managed table does not move files to a recoverable trash location with a guaranteed UNDROP window in the general Unity Catalog model.

Auto-termination ensures the cluster shuts down after a configurable period of inactivity, controlling costs. Attaching the cluster to an instance pool means that when users restart it after termination, idle pre-warmed VMs are available, drastically reducing restart time so the experience feels seamless. Option E is wrong because setting minimum workers to 0 with autoscaling does not by itself terminate the cluster driver. Option A is wrong because terminating immediately on notebook detach would be too aggressive and disruptive for active development workflows. Option B is wrong because cluster pinning prevents the cluster from being deleted from the UI history but does NOT prevent auto-termination. Option D is wrong because restricting max workers to 1 limits performance and does not address the cost-vs-restart-time tradeoff described.

Databricks Runtime ML variants (e.g., 15.x ML or 15.x GPU ML) include pre-installed and version-compatible ML frameworks such as TensorFlow, PyTorch, scikit-learn, and CUDA drivers for GPU nodes. This is the correct choice for deep learning workloads. Option A is wrong because although you can manually install TensorFlow on a standard runtime, you risk version incompatibility and lose the pre-tuned, tested ML environment that Runtime ML provides. Option C is wrong because the Databricks Runtime for Genomics is specialized for bioinformatics workflows, not general deep learning. Option D is wrong because Photon is a vectorized SQL/DataFrame execution engine; it does not provide GPU acceleration for deep learning — GPU acceleration requires selecting a GPU node type and an ML runtime.

Unity Catalog supports native column masks via masking policy functions. A masking function can evaluate the current user's group membership and return NULL (or a redacted value) for members of marketing, while returning the real value for privileged users — this is the recommended, scalable approach. Option A (view-based approach) is a valid workaround but is not the recommended Unity Catalog-native method and becomes brittle as the number of consumer groups grows. Option C is incorrect because Unity Catalog does not support DENY commands; it uses a grant-only model. Option D (partition-based restriction) is not a supported access control mechanism in Unity Catalog.

The Unity Catalog system table system.access.audit logs metastore operations. The action_name value for dropping a table is dropTable. This is the correct Unity Catalog-native approach to audit who performed a DDL operation. Option D uses deleteTable which is not the correct action name in Unity Catalog audit logs. Option C (Azure Monitor Activity Log) captures Azure resource-level operations on the Databricks workspace resource itself, not Unity Catalog metastore DDL events. Option A is incorrect — information_schema.table_history does not exist as a Unity Catalog system view; Delta table history (DESCRIBE HISTORY) tracks DML but does not capture who dropped the table after the fact.

Option D is correct. Unity Catalog's ABAC capability lets administrators define policies that grant or restrict access to securables based on tags (key-value pairs) applied to those objects, enabling scalable, metadata-driven access control without individually granting privileges on each table. Option B is wrong because row filter functions operate on row data, not on object-level metadata tags, and cannot be used to block table-level access based on tags. Option A is wrong because dynamic views require manual maintenance and do not constitute a policy-driven ABAC mechanism; they would not scale as new tables are added. Option C is wrong because column masks restrict column values for specific users but do not prevent access to the table itself; using them across all columns is an anti-pattern for table-level access control.

DROP ROW silently removes records that violate the constraint from the target table, effectively quarantining invalid records (they are counted in pipeline metrics but not written to the output table), while allowing the pipeline to continue running. FAIL UPDATE (option C) would halt the entire pipeline update when a violating record is encountered, which contradicts the requirement to not fail the pipeline. WARN (option B) allows violating records to pass through to the target table and only logs a warning — the invalid rows are NOT quarantined. Option A inverts the logic of the constraint expression; it would drop rows where amount IS NULL or <= 0 (written as the expectation condition), but the expression amount IS NULL OR amount <= 0 as the EXPECT clause means rows satisfying that condition are valid, which is backwards from the intended business rule.

Table B is an unmanaged (external) table because it was created with an explicit LOCATION clause pointing to an ADLS path. When an external table is dropped in Unity Catalog, only the metadata registration is removed; the underlying data files remain at the specified storage location. This is the fundamental distinction between managed and unmanaged tables. Option A describes the behavior of dropping a managed table (Table A), where Unity Catalog owns both the metadata and the data, so a DROP deletes both. Option C is incorrect — Unity Catalog allows dropping external tables; UNDROP is a recovery mechanism for managed tables, not a prerequisite for dropping external ones. Option D is entirely fictitious; Unity Catalog does not migrate or convert external table data during a DROP operation.

Liquid clustering on transaction_date and region is the modern, recommended approach for this scenario. It adaptively co-locates data based on both clustering keys without requiring manual OPTIMIZE runs or static partition definitions, and it handles the daily bulk-append pattern efficiently through incremental clustering. Z-ordering alone (option A) co-locates data within individual Parquet files but does not eliminate file-level scanning; without partitioning it would need to scan the entire table first. Partitioning by region with 8 values is acceptable, but static partitioning on a date column at daily granularity creates a very large number of small partitions over time (thousands of partitions per year), causing metadata overhead — this makes option C and D less ideal. Liquid clustering supersedes the partition + Z-order pattern for new tables as of Databricks Runtime 13.3+.

VACUUM table RETAIN 168 HOURS (168 hours = 7 days) is the correct command. VACUUM removes data files that are no longer referenced in the Delta transaction log and are older than the specified retention threshold, reclaiming cloud storage. The default retention is 7 days; specifying 168 HOURS explicitly sets this. — Option D (DELETE with _commit_timestamp filter) deletes logical rows from the table based on a column value, not stale physical files — it does not perform file cleanup and _commit_timestamp is not a standard Delta column. — Option A (OPTIMIZE with ZORDER on _commit_version) is not a valid use of ZORDER — _commit_version is not a user-defined column, and re-running OPTIMIZE does not remove unreferenced files; that is VACUUM's job. — Option C (ALTER TABLE SET TBLPROPERTIES) sets the property that governs the retention period used by future VACUUM runs, but it does not itself clean up any files; you must still run VACUUM explicitly to perform the actual deletion.

Option A is correct: setting cloudFiles.schemaEvolutionMode to 'addNewColumns' instructs Auto Loader to automatically widen the target Delta table schema by adding newly discovered columns, enabling graceful handling of API changes. Option B is correct: Delta Lake enforces the existing schema on writes by default; attempting to write new columns without specifying .option('mergeSchema','true') or setting the table property delta.autoMerge.enabled=true will result in an AnalysisException. Option E is correct: when Auto Loader detects a new column during a streaming batch, it restarts the current micro-batch so the schema change can be committed to the Delta table first, then the data is written with the updated schema — this is expected behavior described in Databricks documentation. Option C is incorrect: Auto Loader persists the inferred schema in a user-specified schema location (cloudFiles.schemaLocation) so it does NOT recompute from scratch on every batch; it reads the cached schema and updates it incrementally. Option D is incorrect: column mapping is a separate Delta feature for renaming/dropping columns; it is not a prerequisite for schema evolution. Option F is incorrect: schema evolution in Delta Lake and Auto Loader handles column additions, not column removals — dropped source fields are not automatically removed from the Delta schema; existing columns simply receive NULL values.

Liquid clustering on both columns (option D) is the recommended modern approach: it clusters data across both dimensions incrementally, avoids partition explosion, and requires no manual OPTIMIZE scheduling. Partition-by-event_date with Z-ordering on region (option C) is also effective: date partitioning prunes large swaths of data for date-range queries while Z-ordering co-locates rows with the same region within each partition, improving skipping for the combined filter. — Periodic OPTIMIZE with ZORDER BY (option E) achieves similar physical layout to option C but without partitioning, meaning the engine must scan all files before Z-order skipping can help; it also requires scheduled manual runs rather than incremental optimization. — Deletion vectors (option A) improve the performance of DELETE and UPDATE operations by marking deleted rows without rewriting files, but they do not improve read scan performance for filter queries. — Partitioning by region alone (option B) with only 10 distinct values would still require full scans within each partition for date filters, poorly addressing the multi-dimensional access pattern.

Setting cloudFiles.schemaEvolutionMode to "addNewColumns" (option D) instructs Auto Loader to detect new fields in incoming JSON files and add them to the inferred schema rather than failing. Setting mergeSchema to true (option E) on the Delta write ensures that when those new columns are detected, they are automatically added to the existing Bronze table schema without requiring a manual ALTER TABLE. Together these two settings achieve seamless schema evolution. Option A (failOnNewColumns) is the opposite of what is needed — it would cause pipeline failures on every new field. Option C (expect_or_fail on all columns) would reject records with new fields, causing data loss. Option B (inferColumnTypes to true) causes Auto Loader to re-infer types on every batch from scratch, which can overwrite existing type decisions and cause type-conflict errors — it does not enable additive schema evolution. Option F (relying on Unity Catalog schema enforcement) would actively block new columns from being written, not allow them.

After redeployment via a Databricks Asset Bundle, a new job resource may be created with a different job ID, leaving alerts configured against the old job ID orphaned and inactive. This is a common post-deployment misconfiguration. Duration alerts in Lakeflow Jobs do fire while the job is still running once the threshold is crossed, so option B is incorrect. Threshold units in the UI are clearly labeled, making option A unlikely as the 'most likely' cause. Lakeflow Jobs do support duration-based alerting, making option D factually wrong.

A Continuous trigger (also described as 'run when previous run completes' semantics) immediately queues the next run as soon as the preceding run finishes, minimizing idle time without requiring a fixed schedule. This is the correct choice. Option A is incorrect because a 1-minute cron schedule introduces up to 1 minute of latency between runs and may overlap or waste time if the job takes less or more than 1 minute. Option C is incorrect because a file arrival trigger fires when new files land in a configured location, which is event-driven and not tied to job completion. Option D is incorrect because using a monitoring script adds operational overhead and is not a native Databricks trigger type; it also introduces latency from the polling interval.

VACUUM removes files that are no longer referenced by the Delta log and that are older than the retention threshold. The default retention period is 7 days (168 hours), which protects time-travel queries for up to 7 days. Option B is wrong because the default is 7 days, not 24 hours; running VACUUM with less than 7 days requires explicitly overriding the safety check and is generally discouraged unless you understand the time-travel impact. Option A is wrong because ZORDER is a data layout optimization (co-locating related data) that is applied as part of OPTIMIZE — it does not delete obsolete files and has no compaction window concept. Option D is wrong because ANALYZE TABLE refreshes column statistics for the query optimizer but does not reclaim storage or remove old data files.

B, C and E reduce shuffle volume and spill. Broadcasting small dimension tables removes their shuffle (B); AQE coalesces partitions, handles skew and can switch to broadcast joins at runtime (C); filtering and pre-aggregating early shrinks the data that enters the shuffle (E). Option A can ease per-partition memory pressure but adds tasks and doesn't reduce shuffle volume, so it is less effective. Option D creates a few huge partitions and makes spill worse. Option F gives up Photon's vectorised execution without reducing the shuffle.

Using short-lived feature branches (Option A) reduces the risk of merge conflicts because branches diverge from main for a shorter time, and combining this with protected branch policies requiring PR review (Option B) ensures that no code reaches main without human review, satisfying all three requirements. Option D is incorrect because committing directly to main bypasses code review and risks introducing broken code to production. Option C is incorrect because long-lived branches accumulate more divergence from main, dramatically increasing the likelihood and complexity of merge conflicts. Option E is incorrect because having one person rewrite conflicting code without review undermines the review process and introduces risk of errors.

The default VACUUM retention period is 7 days (168 hours). To support 30-day time travel, two complementary changes are needed: (1) Setting the delta.deletedFileRetentionDuration table property to 30 days ensures that Delta itself tracks and retains the required data files as part of its metadata management. (2) Specifying RETAIN 720 HOURS in the VACUUM command explicitly overrides the default 168-hour threshold, preventing the command from deleting files needed for 30-day time travel. Together, these changes ensure both the table metadata and the physical files are preserved for the desired retention window. Option F is incorrect because OPTIMIZE frequency does not affect time travel retention; OPTIMIZE compacts files but VACUUM is what deletes old data files. Option E is incorrect because this is the exact opposite of the goal — it would destroy all historical data immediately. Option C is incorrect because CDF captures incremental changes for downstream consumers but does not preserve the underlying data files that VACUUM would delete; time travel still depends on the physical Parquet files. Option A is incorrect because shallow clones reference the source table's files and do not create independent copies; if VACUUM deletes files from the source, the shallow clone will also lose access to them.

When you repair a Databricks Job run, only the failed task and all downstream tasks that were skipped or not yet executed are re-run. Task A succeeded, so it is not re-executed. Task B failed, and Task C was skipped because its dependency (B) failed — both are included in the repair. Option A is wrong because Task C was blocked by the failure and must also be re-run to complete the pipeline. Option C is wrong because re-running successful upstream tasks wastes resources and is not the repair behavior; Databricks preserves successful task results. Option D is wrong because Task C is downstream of the failure and must be included; Task A was successful and is excluded.