DP-750 Practice Questions — Page 2

You are onboarding a new data engineer to a Unity Catalog-enabled Azure Databricks workspace. They ask you to explain how the objects in the following script relate to one another and which one governs non-tabular data such as PDF and image files.

```sql

CREATE CATALOG IF NOT EXISTS prod;

CREATE SCHEMA IF NOT EXISTS prod.crm;

CREATE TABLE prod.crm.customers (id BIGINT, name STRING);

CREATE VOLUME prod.crm.raw_documents;

```

Which statement correctly describes the Unity Catalog object model represented by this script?

A logistics company captures large collections of unstructured files — scanned bills of lading (PDF), dash-cam video, and IoT sensor logs — into an existing Azure Data Lake Storage Gen2 container at `abfss://[email protected]/incoming/`. These files are written **directly by external capture systems** that run outside Azure Databricks and must continue to write to that exact path. The data engineering team wants to govern access to these files from Databricks with Unity Catalog while leaving the files in place and allowing the external systems to keep reading and writing them.

Which type of Unity Catalog volume should the team create, and why?

A data engineering team is designing the serving layer of a Unity Catalog `analytics` schema. For each of the following requirements, choose the most appropriate Unity Catalog object. Assume Databricks SQL with serverless compute is available and that materialized views can be created and refreshed standalone.

```mermaid

flowchart TD

subgraph Req1[Requirement 1]

R1[Store raw ingested transaction rows that downstream jobs run INSERT, UPDATE, DELETE, and MERGE INTO against]

O1{Object: managed table / view / materialized view}

end

subgraph Req2[Requirement 2]

R2[Expose a column-renamed, business-friendly projection of a table with NO extra storage and results that are always live at query time]

O2{Object: managed table / view / materialized view}

end

subgraph Req3[Requirement 3]

R3[Precompute an expensive GROUP BY aggregation so a BI dashboard reads cached results with low latency, refreshed on a schedule and incrementally when possible]

O3{Object: managed table / view / materialized view}

end

subgraph Req4[Requirement 4]

R4[Provide a session-scoped projection inside a single notebook that disappears when the notebook detaches]

O4{Object: temporary view / external table / materialized view}

end

```

An analytics team needs read-only access to operational tables that live in an existing Azure Database for PostgreSQL server. The data must **not** be copied into Azure Databricks; analysts should query it live and have access managed by Unity Catalog using normal `GRANT` statements. A platform admin has already run the following statement:

```sql

CREATE CONNECTION pg_ops TYPE postgresql

OPTIONS (

host '<server>.postgres.database.azure.com',

port '5432',

user '<user>',

password secret('ops','pg_pwd')

);

```

Which command completes the Lakehouse Federation setup so that the PostgreSQL database `orders_db` is mirrored as a queryable catalog in Unity Catalog?

A data engineer in a Unity Catalog-enabled workspace creates two tables in the `prod.silver` schema:

```sql

-- Table 1: storage location chosen by Unity Catalog

CREATE TABLE prod.silver.orders_managed (id BIGINT, total DECIMAL(10,2));

-- Table 2: data files live in customer-owned cloud storage

CREATE TABLE prod.silver.orders_external (id BIGINT, total DECIMAL(10,2))

USING DELTA

LOCATION 'abfss://[email protected]/orders/';

```

Later, both tables are dropped:

```sql

DROP TABLE prod.silver.orders_managed;

DROP TABLE prod.silver.orders_external;

```

What is the result for the underlying data files of each table immediately after the `DROP TABLE` statements run?

You are scripting the creation of a new governed data area in a Unity Catalog metastore that already has a metastore-level managed storage location. The end state must be a managed Delta table named `finance.reporting.gl_balances`. The four DDL statements below are shown out of order. Arrange them into the sequence in which they must execute so that each object's parent already exists when it is created, and so that the table is a Unity Catalog **managed** table.

```mermaid

flowchart LR

subgraph Tiles[DDL statements to order]

T1["CREATE SCHEMA IF NOT EXISTS finance.reporting;"]

T2["CREATE TABLE finance.reporting.gl_balances (account STRING, balance DECIMAL(18,2));"]

T3["CREATE CATALOG IF NOT EXISTS finance;"]

T4["GRANT USE CATALOG ON CATALOG finance TO `reporting_team`;"]

end

S1[Step 1] --> S2[Step 2] --> S3[Step 3] --> S4[Step 4]

```

A data team is curating an AI/BI Genie Space over a Unity Catalog `sales` schema so that business users can ask natural-language questions and receive accurate, trusted answers. Genie behaves nondeterministically, so the team wants to maximize the chance of correct, verifiable SQL while following Databricks' recommended curation practices.

Which **three** actions should the team take to improve the Genie Space's accuracy and data discovery? (Choose THREE.)

A data platform team at Contoso manages a Unity Catalog metastore. A nightly ingestion job runs as an Azure Databricks **service principal** named `ingest-sp` (application ID `a1b2c3d4-1111-2222-3333-444455556666`). The job must be able to read from and write to every current and future table in the `sales` schema of the `prod` catalog, but it must not be able to create new tables or alter privileges.

You connect to a SQL warehouse as the owner of the `prod` catalog and run a sequence of `GRANT` statements. Which statement set correctly gives the service principal exactly the access it needs, following the Unity Catalog privilege model?

```sql

-- Option building blocks (do not run yet)

GRANT USE CATALOG ON CATALOG prod TO `a1b2c3d4-1111-2222-3333-444455556666`;

GRANT USE SCHEMA ON SCHEMA prod.sales TO `a1b2c3d4-1111-2222-3333-444455556666`;

GRANT SELECT, MODIFY ON SCHEMA prod.sales TO `a1b2c3d4-1111-2222-3333-444455556666`;

```

An analyst group named `bi_readers` must be able to run `SELECT * FROM finance.reporting.gl_summary` on a SQL warehouse in a Unity Catalog metastore. The table owner has already granted `SELECT` on the table `finance.reporting.gl_summary` to `bi_readers`, but the query still fails with a permission error.

You must determine the complete set of grants required for each level of the three-level namespace so that the read succeeds. For each securable level shown, select the **minimum** privilege that `bi_readers` must hold.

```mermaid

flowchart TD

A["CATALOG: finance<br/>dropdown -> ?"] --> B["SCHEMA: finance.reporting<br/>dropdown -> ?"]

B --> C["TABLE: finance.reporting.gl_summary<br/>dropdown -> ?"]

subgraph Options

O1["USE CATALOG"]

O2["USE SCHEMA"]

O3["SELECT"]

O4["BROWSE"]

O5["MODIFY"]

end

```

A `customers` table in Unity Catalog contains an `email` column. Compliance requires that only members of the account-level group `auditors` can see the full email address; all other users must see only the email domain (for example, `contoso.com`). You must implement this with a single Unity Catalog mechanism that returns the masked value at query time and works for SQL warehouse queries.

You are deciding between a dynamic view and a table-level column mask. The team chooses a **column mask** so the protection follows the base table and does not require analysts to query a different object name. Which implementation correctly applies column-level masking?

```sql

-- Candidate implementation

CREATE FUNCTION email_mask(email STRING)

RETURN CASE

WHEN is_account_group_member('auditors') THEN email

ELSE regexp_extract(email, '^.*@(.*)$', 1)

END;

ALTER TABLE customers ALTER COLUMN email SET MASK email_mask;

```