Free Databricks Certified Data Analyst Associate Sample Questions

Correct answer: D — A new read-only catalog containing the shared data appears and is ready to be queried.

• A. Incorrect. The 'Get instant access' feature provisions access to data, not compute resources. Cluster management is a separate process that must be performed by the user to query the newly available data.
• B. Incorrect. Databricks Marketplace uses Delta Sharing to provide live, direct access to the data within the Databricks workspace. The data is not downloaded as a static file or ZIP archive to the user's local machine.
• C. Incorrect. The purpose of the 'Get instant access' feature is to provide immediate, programmatic access without requiring a manual approval workflow or waiting period. While some listings may require a request, this specific feature bypasses that process.
• D. Correct. When an analyst uses 'Get instant access' on Databricks Marketplace, the underlying Delta Sharing protocol instantly creates a new read-only catalog in their Unity Catalog metastore. This catalog points to the shared data, making it immediately available for querying using standard SQL, assuming the user has access to a running compute resource.

Correct answer: D — Unity Catalog

• A. Incorrect. 'Lakeflow' is a term associated with Databricks' capabilities for building data pipelines, but 'Lakeflow Jobs' is not a specific component. ETL and data transformation tasks are orchestrated using Databricks Workflows (Jobs), while the lineage from these activities is captured by a different component.
• B. Incorrect. The Data Intelligence Engine is a broad term for the collection of AI-powered features across the Databricks platform that learn from data and metadata. While it powers features like lineage, it is not the specific component that captures and exposes lineage data to users. That function is performed by Unity Catalog.
• C. Incorrect. Mosaic AI is a specialized framework within Databricks designed for large-scale AI and analytics on geospatial and raster data. Its focus is on spatial data processing and modeling, not general data lineage tracking.
• D. Correct. Unity Catalog is the unified governance solution for data and AI assets on Databricks. A key feature of Unity Catalog is its ability to automatically capture data lineage at the table and column level across all languages and workloads (notebooks, jobs, dashboards). This allows analysts to visualize the entire data journey, from source tables through transformations to the final dashboard, fulfilling the exact requirement of the scenario.

Correct answer: C — GRANT SELECT ON TABLE sales.emea.quarterly_reports TO `analyst@company.com`;

• A. Incorrect. The `ALL PRIVILEGES` command grants all possible permissions, including read (`SELECT`), write (`MODIFY`), and ownership rights. This violates the principle of least privilege, as the request is only for read-only access.
• B. Incorrect. The `USAGE` privilege is required on the parent catalog and schema to allow the user to access objects within them. However, on a table, `USAGE` does not grant permission to read its data; it only makes the object 'visible'. Therefore, it is insufficient for read-only access.
• C. Correct. The `SELECT` privilege grants the specific ability to read data from a table using a `SELECT` statement. This directly corresponds to the 'read-only' requirement and is the minimal privilege needed to satisfy the analyst's request.
• D. Incorrect. The `MODIFY` privilege grants permissions to alter the data within the table (e.g., `INSERT`, `UPDATE`, `DELETE`). This is a write-level permission and is excessive for a user who only needs to read the data.

Correct answer: B — In a central metastore at the Databricks account level.

• A. Incorrect. While Parquet file footers contain some data-related metadata like schema and statistics, they do not store the governance metadata such as permissions, comments, and ownership that is managed by Unity Catalog.
• B. Correct. Unity Catalog's core feature is a central metastore that operates at the Databricks account level. This enables unified data governance, access control, and discovery across all workspaces attached to that account, breaking down data silos.
• C. Incorrect. This describes the legacy Hive metastore model, which is local and scoped to a single Databricks workspace. Unity Catalog was introduced specifically to overcome this limitation by centralizing metadata at the account level.
• D. Incorrect. Storing governance metadata in hidden files alongside the data is not a practice used by Unity Catalog. All metadata is managed centrally and securely within the metastore, separate from the physical data files in cloud storage.

Correct answer: C — Click on the Job node in the lineage graph to navigate directly to the job run history.

• A. Incorrect. While examining the upstream source data might be a necessary step in the overall debugging process, it is not the most direct next step to investigate the *transformation logic*. The immediate question is what the job did to the data, making the job itself the primary focus.
• B. Incorrect. The problem originates in the data pipeline that creates the `gold.customer_ltv` table, not the downstream dashboard that consumes it. The lineage graph's primary value here is showing the upstream dependencies and processes, so investigating the job is the correct direction.
• C. Correct. The data lineage graph in Catalog Explorer is interactive. The nodes, including jobs, are clickable links. Clicking on the Job node provides a direct hyperlink to the Databricks Job's page, where the analyst can view recent runs, access logs, and inspect the code containing the transformation logic. This is the most efficient and direct path to begin debugging the issue.
• D. Incorrect. Adding a tag is a useful data governance practice to communicate the status of a data asset to other users. However, it is a metadata management action and does not contribute to the technical debugging of the transformation logic.

Correct answer: A — SELECT DISTINCT * FROM user_activity;

• A. This is the correct and most direct solution. The `SELECT DISTINCT *` statement is the standard SQL method for retrieving unique rows from a table, where uniqueness is evaluated based on the values in all columns. It is the most straightforward and efficient way to eliminate exact duplicate rows as described in the problem.
• B. This approach using the `ROW_NUMBER()` window function with `QUALIFY` is a valid technique for deduplication, but it is more complex than necessary for this specific problem. To guarantee uniqueness across the entire row, all columns would need to be listed in the `PARTITION BY` clause. The provided query is incomplete as it only partitions by a subset of columns, which could lead to incorrect results if other columns exist. It is not the most direct method.
• C. This query is syntactically invalid in SQL. Aggregate functions like `COUNT(*)` cannot be used directly in a `WHERE` clause. Such filtering must be done in a `HAVING` clause after a `GROUP BY`, or by using a subquery. This query would result in a SQL error.
• D. This query is syntactically invalid. The `UNIQUE` keyword is not a standard SQL keyword for selecting distinct rows in a `SELECT` statement. The correct and standard keyword for this operation is `DISTINCT`. This query would result in a syntax error in Databricks SQL.

Correct answer: C — Notebooks, solution accelerators, and AI models.

• A. Incorrect. Custom cluster configurations and initialization scripts are specific to an organization's needs and security policies. They are managed within a Databricks workspace and are not considered shareable assets on the public Marketplace.
• B. Incorrect. The Databricks platform source code and binaries are proprietary intellectual property of Databricks. They are not distributed or made available through the Marketplace.
• C. Correct. The Databricks Marketplace is designed to share not just datasets but also other data and AI assets. This includes pre-built notebooks, solution accelerators (which are end-to-end solutions for specific use cases), and trained AI models to help users accelerate their data and AI projects.
• D. Incorrect. Professional services and support contracts are business services, not digital assets. These are arranged through direct engagement with Databricks or its partners and are not listed or shared on the Marketplace platform.

Correct answer: A — The table will be created successfully, with the header row appearing as the first row of data and columns having generic names like `_c0`, `_c1`.

• A. Correct. When the 'First row contains header' option is not selected, the system treats the first row as data. The table is created successfully, the header row becomes the first record, and columns receive generic names like `_c0`, `_c1`.
• B. Incorrect. The upload process will not fail with a data type mismatch error. The header text is ingested as the first row of data, and the system typically infers string types for all columns based on that row, avoiding type conflicts.
• C. Incorrect. The system does not automatically detect the header row unless the option is checked. Without it, every row, including the first, is treated as a data record, and no automatic labeling occurs.
• D. Incorrect. The header row is not dropped; it is preserved as the first data row. Columns receive default names like `_c0`, not `col1`, and no data loss occurs.

Correct answer: B — Unity Catalog

• A. Incorrect. Databricks Repos is a feature for version control and source code management, integrating with Git providers to collaborate on notebooks and code. It does not provide the schema metadata required for intelligent SQL auto-completion.
• B. Correct. Unity Catalog is the centralized, unified governance solution for all data and AI assets in Databricks. It serves as the metadata layer, providing the detailed schema information for catalogs, schemas, tables, and functions that the Databricks Assistant leverages to offer contextual auto-completion during query authoring.
• C. Incorrect. Databricks Jobs is a service used to schedule and run automated workloads, such as ETL pipelines or notebooks, on the Databricks platform. It is not involved in providing real-time metadata for query assistance.
• D. Incorrect. DBFS (Databricks File System) is a distributed file system mounted into a Databricks workspace that allows you to interact with data in cloud object storage. While it stores data, it does not supply the structured metadata or schema context necessary for query auto-completion.

Correct answer: A — To provide the compute resources required to execute SQL queries and BI workloads.

• A. This is the correct answer. A SQL Warehouse is the dedicated compute engine within the Databricks SQL environment. Its primary function is to provide the optimized compute resources (CPU, memory, I/O) necessary to execute SQL queries, dashboards, and BI workloads efficiently against data in the lakehouse.
• B. Incorrect. SQL Warehouses are compute resources, not storage resources. The underlying data files for tables and views are stored in cloud object storage as part of the Databricks Lakehouse Platform, typically using the Delta Lake format.
• C. Incorrect. While permissions can be set on who can *use* a SQL Warehouse, the warehouse itself does not manage permissions to data objects like tables or views. Data governance and access control are managed at the platform level, primarily through Unity Catalog or legacy table ACLs.
• D. Incorrect. The web-based interface, including the SQL Editor, is part of the Databricks workspace application. The SQL Warehouse is the backend compute engine that executes the queries submitted via the editor or other clients, but it does not host the user interface components.

Correct answer: B — SELECT u.user_id, l.activity FROM main.default.users u JOIN postgres_prod.public.user_logs l ON u.user_id = l.user_id;

• A. Incorrect. This query fails to correctly reference the remote table in the PostgreSQL database. To query a table through a foreign catalog, it must be fully qualified with the `catalog.schema.table` format. The query is missing the `postgres_prod.public` prefix for the `user_logs` table, which would cause the query to look for a local table with that name.
• B. Correct. This query correctly uses Databricks' three-level namespace (`catalog.schema.table`) to join a local table with a remote table. The local Delta table is fully qualified as `main.default.users`, and the remote PostgreSQL table is correctly referenced through the foreign catalog as `postgres_prod.public.user_logs`. This is the standard syntax for executing federated queries in Databricks SQL.
• C. Incorrect. This query is improperly formatted because neither table is fully qualified. The local table `users` is missing its catalog and schema (`main.default`), and the remote table `postgres_prod.user_logs` is missing its schema (`public`). Both are required for the query to execute successfully.
• D. Incorrect. The `FEDERATED JOIN` keyword is not valid syntax in Databricks SQL. Databricks leverages the three-level namespace and foreign catalogs to perform federated queries using standard `JOIN` syntax. The distinction of a federated query is made by referencing a table in a foreign catalog, not by using a special join keyword.

Correct answer: C — The data types of the second column (`product_name` as STRING and `last_purchase_date` as DATE) are not compatible.

• A. Incorrect. The `UNION` operator aligns columns by position, not by name. Different column names do not cause a failure as long as the number of columns and their data types are compatible.
• B. Incorrect. `UNION` is designed to combine rows from different tables or queries. There is no requirement that both queries reference the same source table.
• C. Correct. `UNION` requires corresponding columns to have compatible data types. Here, the second columns are `STRING` and `DATE`, which are incompatible and cause the query to fail.
• D. Incorrect. An `ORDER BY` clause is optional in a `UNION` query. Its absence does not prevent the query from executing.

Correct answer: C — A standard (dynamic) view, because it queries the base table directly every time.

• A. Incorrect. A materialized view stores pre-computed results, so even if refreshed every second, it cannot guarantee the absolute most current data when the source table updates multiple times per second. Any ticks arriving between refreshes would be missed, violating the requirement for always-fresh data.
• B. Incorrect. A streaming table is a table type used for continuous ingestion and processing in Delta Live Tables, not a view. The question explicitly asks for a type of view, making this option unsuitable.
• C. Correct. A standard (dynamic) view is a stored query that executes against the base table every time it is queried. This ensures the result always reflects the latest data, even with high-frequency updates, meeting the requirement for absolute freshness.
• D. Incorrect. A temporary view is session-scoped but otherwise behaves like a standard view, querying the base table directly. Its temporary nature does not improve data freshness or performance over a permanent standard view, and it does not inherently provide the fastest access.

Correct answer: B — `COUNT(*)` counts all rows in a group, while `COUNT(column_name)` counts only the rows where `column_name` is not NULL.

• A. Incorrect. Both `COUNT(*)` and `COUNT(column_name)` provide accurate counts for their respective definitions. `COUNT(*)` is not inherently faster or less accurate; the difference lies in how they handle NULL values. Databricks documentation does not describe one as faster or less accurate.
• B. Correct. According to Databricks SQL documentation, `COUNT(*)` counts all rows in a group, including rows that contain NULL values. In contrast, `COUNT(column_name)` ignores NULLs and counts only rows where the specified column is not NULL. This is a fundamental distinction in SQL aggregation semantics.
• C. Incorrect. `COUNT(column_name)` works on columns of any data type (string, numeric, boolean, etc.). Its purpose is to count non‑NULL occurrences, not to restrict input to numeric columns. Neither the Databricks SQL reference nor SQL standards impose such a limitation.
• D. Incorrect. Databricks SQL treats `COUNT(*)` and `COUNT(column)` differently. `COUNT(*)` counts whole rows regardless of NULLs, while `COUNT(column)` excludes NULL values for that column. There is no automatic substitution of a primary key, and the results can differ when the column contains NULLs. The two are not interchangeable.

Correct answer: B — To rewrite and optimize Spark SQL queries for better performance on large datasets.

• A. Incorrect. Photon is a query engine that runs on compute resources, not the compute layer itself. While Databricks offers serverless compute, which abstracts infrastructure management, Photon's role is to optimize query execution on that compute, not provide the serverless functionality.
• B. Correct. Photon is a high-performance, native vectorized query engine written in C++ that is designed to accelerate Spark SQL and DataFrame API workloads. It rewrites and optimizes query plans to leverage modern CPU architecture, resulting in significant performance improvements, especially for large datasets.
• C. Incorrect. The management and version control of workspace assets like notebooks and files are handled by other components of the Databricks platform, such as the Databricks Workspace UI and Databricks Repos (for Git integration), not by the Photon query engine.
• D. Incorrect. Photon is a performance engine and is not involved in security or governance. Fine-grained access control on data objects like tables and views is managed by features like Unity Catalog or legacy table access control lists (ACLs).

Correct answer: C — A new row of data is inserted into the `sales_orders` table.

• A. Incorrect. The Query Result Cache in Databricks is global and shared across all users in a workspace. If a different user runs the exact same query text on unchanged data, Databricks will serve the result from the cache. This action would result in a cache hit, not an invalidation.
• B. Incorrect. The Query Result Cache is managed by the Databricks control plane and is independent of the SQL warehouse's compute resources. Restarting the warehouse does not affect or invalidate the cache. The cache persists until the underlying data changes.
• C. Correct. The primary condition for invalidating the Query Result Cache is a change to the underlying data. Inserting a new row into the `sales_orders` table is a data modification (DML) operation. To ensure result accuracy, Databricks automatically invalidates any cached results for queries that depend on this table.
• D. Incorrect. The Query Result Cache relies on an exact, byte-for-byte match of the SQL query text. Adding a comment changes the query text, making it a new, distinct query. This will result in a cache miss for the new query, but it does not invalidate the cached result of the original query (without the comment). The original cache entry remains valid.

Correct answer: C — The time taken to parse the SQL, analyze it, and generate an optimized execution plan.

• A. Incorrect. This option describes the time spent on data shuffling, which is the physical transfer of data between worker nodes. This activity is part of the query execution phase, not the compilation phase.
• B. Incorrect. This option describes queue time. It represents the time a query waits for warehouse resources to become available before it can be processed. This is a resource availability metric, distinct from the time spent preparing the query plan.
• C. Correct. This metric represents the overhead before query execution begins. It encompasses the time required to parse the SQL statement for correct syntax, analyze it to resolve objects and check semantics, and for the query optimizer to generate the most efficient physical execution plan.
• D. Incorrect. This describes the query execution time, which is the phase where the compiled plan is run against the data, often accelerated by an engine like Photon. This happens after the compilation phase is complete.

Correct answer: C — CLUSTER BY

• A. Incorrect. The `PARTITIONED BY` clause is used for traditional, static partitioning of a table. This physically divides data into directories based on low-cardinality column values. A Delta table can be either partitioned or have liquid clustering enabled, but not both.
• B. Incorrect. The `ZORDER BY` clause is used with the `OPTIMIZE` command to improve data skipping by co-locating related column information within data files. It is an optimization technique that is separate from Liquid Clustering and is not used during table creation to enable it.
• C. Correct. The `CLUSTER BY` clause is the specific SQL syntax used within a `CREATE TABLE` statement to enable Liquid Clustering on a new Delta table. It defines the columns on which to cluster the data, providing a more flexible and efficient data layout than traditional partitioning, especially for high-cardinality columns.
• D. Incorrect. `LIQUID ON` is not a valid SQL clause in Databricks SQL for enabling Liquid Clustering or for any other table definition purpose.

Correct answer: A — SELECT * FROM customer_profiles VERSION AS OF 142

• A. Correct. This query uses the standard and most explicit SQL syntax for Delta Lake time travel. The `VERSION AS OF` clause instructs the query engine to retrieve the snapshot of the table as it existed exactly at version 142, which is the desired operation.
• B. Incorrect. The `DESCRIBE HISTORY` command is used to view the metadata of the transaction log, such as the operation performed, user, and timestamp for each version. It does not return the actual data from the table at that version.
• C. Incorrect. While this is a valid Databricks-specific shorthand syntax for time travel, `VERSION AS OF` is the standard Delta Lake syntax and the more formally correct answer. Certification exams typically test on the standard, explicit syntax.
• D. Incorrect. Delta Lake's versioning information is not stored in a queryable column within the table itself. Time travel must be performed using a special clause after the table name, not with a standard `WHERE` clause.

Correct answer: C — JOIN calendar c ON CAST(e.event_timestamp AS DATE) = c.cal_date

• A. Incorrect. Databricks SQL does not have a `TO_STRING` function; this query would fail with a syntax error. The correct function for casting to a string is `CAST(... AS STRING)`. Furthermore, comparing string representations of dates and timestamps is inefficient and can lead to incorrect results if the string formats do not match exactly (e.g., '2023-10-27 10:00:00' does not equal '2023-10-27').
• B. Incorrect. This syntax is unreliable for two reasons in Databricks SQL. First, the standard function to add a day to a date is `date_add(c.cal_date, 1)`, not `c.cal_date + 1`. Second, directly comparing a `TIMESTAMP` with a `DATE` is not recommended as it can lead to unexpected implicit casting and unreliable results. Best practice is to explicitly cast to a common type.
• C. Correct. This is the standard and most reliable method for this task in Databricks SQL. The `CAST(e.event_timestamp AS DATE)` function correctly truncates the time component from the timestamp, resulting in a `DATE` value. This allows for a direct and accurate equality comparison between two columns of the same `DATE` type, ensuring the join is both correct and readable.
• D. Incorrect. Although the `::` syntax is a valid way to cast data types, this modification does not solve the underlying problem. It casts the left side to a `DATE` and the right side to a `TIMESTAMP`. The join condition is still comparing a `DATE` to a `TIMESTAMP` (e.g., `2023-10-27` vs `2023-10-27 00:00:00`), which is not a reliable comparison and fails to properly align the data types for a correct join.

Correct answer: C — Line Chart

• A. A bar chart is not the best choice for showing continuous trends over time. While it can display monthly revenue, it's better suited for comparing discrete categories. The visual discontinuity between bars makes it less effective than a line chart for identifying seasonal patterns and overall growth trends.
• B. A pie chart is inappropriate for this task. It is designed to show the proportions and percentages of a whole at a single point in time, not for displaying trends or patterns over multiple time periods.
• C. A line chart is the most appropriate visualization for displaying time-series data. It effectively connects sequential data points (monthly revenue) over a continuous interval (three years), making it ideal for clearly illustrating trends, seasonal patterns, and overall growth.
• D. A histogram is used to represent the frequency distribution of a numerical dataset by grouping values into ranges or bins. It is not suitable for showing how a value changes over time, and therefore cannot be used to identify trends or seasonality.

Correct answer: B — Line Chart

• A. Incorrect. A pie chart is used to show the proportional distribution of different categories as parts of a whole at a single point in time. It is not suitable for displaying trends over a continuous period.
• B. Correct. A line chart is the most appropriate visualization for showing trends over a continuous interval or time series. It connects individual data points with lines, making it easy to see how a value, like monthly revenue, changes sequentially over time.
• C. Incorrect. A scatter plot is primarily used to visualize the relationship and correlation between two different numerical variables. While it can plot data points over time, it is not the optimal choice for clearly displaying a continuous trend.
• D. Incorrect. A histogram is used to show the frequency distribution of a single numerical variable by grouping the data into bins. It illustrates how often values fall into certain ranges, not how a value changes over time.

Correct answer: B — Create the dashboard and add each dataset to the dashboard's 'Data' tab, then build visualizations from each.

• A. Incorrect. While joining datasets is a common data preparation step, it is not a prerequisite for creating a dashboard with visualizations from separate data sources. Databricks dashboards are designed to support multiple, distinct datasets on a single canvas.
• B. Correct. This describes the standard workflow in Databricks. An analyst can create a new dashboard, navigate to its 'Data' tab, and add multiple datasets (tables or views). After the datasets are available to the dashboard, they can create individual widgets or visualizations on the canvas, selecting the appropriate dataset for each one.
• C. Incorrect. A key feature of Databricks dashboards is the ability to consolidate information from various sources. They are explicitly not limited to a single dataset, allowing for the creation of comprehensive views with visualizations from multiple tables or queries.
• D. Incorrect. Text widgets are intended for adding descriptive text, titles, or annotations to a dashboard. They are not used for importing or connecting to data sources. The correct method for adding a dataset to a dashboard is through the dedicated 'Data' tab.

Correct answer: C — Query Based Dropdown List

• A. Incorrect. A Text parameter type allows for free-form text input. It does not provide a pre-populated list of options for the user to select from, making it unsuitable for this requirement.
• B. Incorrect. A Dropdown List parameter uses a static list of values that are defined when the parameter is created. It does not automatically update when the underlying data source changes, so it would not reflect the daily updates to the campaign list.
• C. Correct. A Query Based Dropdown List parameter dynamically populates its options by executing a query against a table. This is the ideal solution because it will query the `marketing_campaigns` table each time the dashboard is refreshed, ensuring the dropdown filter always displays the most current list of campaign names.
• D. Incorrect. A Date parameter is used specifically for selecting dates or date ranges from a calendar widget. It is not relevant for selecting textual values like campaign names.

Correct answer: A — `low_stock_items` is greater than 0

• A. Correct. The query calculates the total number of products with a quantity of 10 or less and names this count `low_stock_items`. The business requirement is to send an alert if this number 'exceeds zero'. Therefore, the correct trigger condition is to check if the value of `low_stock_items` is greater than 0, which signifies that there is at least one low-stock product.
• B. Incorrect. This condition would trigger an alert even when the count of low-stock items is zero (since 0 <= 10), which does not meet the requirement. The alert should only trigger when the count is strictly greater than zero.
• C. Incorrect. The alert trigger condition must be based on the output column(s) of the query. The `quantity_on_hand` column is used in the `WHERE` clause for filtering but is not part of the final result set returned by the `SELECT` statement. The only available column for the trigger is the aggregated count aliased as `low_stock_items`.
• D. Incorrect. Similar to `quantity_on_hand`, the `product_id` column is not present in the query's final result set and cannot be used in the trigger condition. Furthermore, checking for non-null product IDs is logically unrelated to the goal of identifying when the count of low-stock items exceeds zero.

Correct answer: B — The dashboard becomes an ownerless object, and a workspace admin must transfer its ownership to another user.

• A. Incorrect. To prevent the loss of valuable organizational assets, Databricks workspace objects like dashboards, queries, and notebooks are not automatically deleted when the owner's user account is removed. The object is retained within the workspace.
• B. Correct. When a user is removed from a Databricks workspace, the dashboards they own become 'ownerless' objects. A workspace administrator must then use the workspace UI or API to find these ownerless objects and explicitly transfer ownership to another active user or group to ensure continued management and access.
• C. Incorrect. Ownership transfer is not an automatic process based on existing permissions like 'CAN MANAGE'. The system does not infer a new owner. An explicit administrative action is required to reassign ownership of the ownerless dashboard.
• D. Incorrect. The dashboard's state does not automatically change to read-only. It simply lacks an owner, which can affect its management. Administrative intervention is necessary to assign a new owner and restore full management functionality, but its accessibility to others with existing permissions is not immediately changed to read-only.

Correct answer: C — A SQL warehouse to run the queries.

• A. This is incorrect. A destination for email alerts is an optional feature used for sending notifications about the refresh status, such as success or failure. It is not a requirement for the scheduled refresh to run.
• B. This is incorrect. By default, a scheduled dashboard refresh runs with the owner's permissions. While you can configure credentials ('Run as viewer' vs 'Run as owner'), you are not required to select a specific, different user for the schedule to execute.
• C. This is correct. A SQL warehouse is the compute resource required to execute the SQL queries that populate the dashboard's visualizations. Without selecting an active warehouse, there is no engine to run the refresh logic, making it a mandatory prerequisite for any scheduled execution.
• D. This is incorrect. The schedule, which can be defined using a UI or cron syntax, determines *when* the refresh occurs. It is part of the schedule's definition, not the compute resource needed for the execution itself. The SQL warehouse is the essential component that performs the execution at the scheduled time.

Correct answer: C — By offering an intuitive, conversational interface that abstracts away the underlying SQL complexity.

• A. Incorrect. Advanced cluster configuration options are intended for data engineers or power users to optimize performance, not for business users. This feature would increase, rather than decrease, the complexity for the target audience.
• B. Incorrect. Forcing users to learn a strict data modeling schema adds another layer of complexity and a learning curve, which acts as a barrier to data exploration, directly contradicting the goal.
• C. Correct. The primary value of a Genie space is its ability to translate natural language questions into SQL queries. This intuitive, conversational interface abstracts the underlying technical complexity, allowing non-technical users to explore data and get answers without needing to write code or navigate complex BI tool interfaces.
• D. Incorrect. Requiring users to learn a programming language like Python would create a significant barrier to entry for data exploration, which is the opposite of the intended purpose of a Genie space.

Correct answer: C — At least 'Can View' on the Genie space and appropriate permissions on the underlying data objects (tables/views).

• A. Incorrect. Both 'Can Manage' on the Genie space (which allows changing permissions, ownership, and deletion) and admin rights on the workspace are excessive permissions for a user who only needs to view data. These are administrative-level privileges, not required for read-only access.
• B. Incorrect. While a user does need permission to use a SQL Warehouse to run the underlying queries, the 'Can Edit' permission on the Genie space allows for modification of the space itself, which is not required for simply viewing the data. A view-only user does not need edit rights.
• C. Correct. This option accurately describes the two essential layers of permissions. The user must first have at least 'Can View' permission to access the Genie space (the container). Second, to see the actual data within the visualizations, the user must have the necessary permissions (e.g., SELECT and USAGE) on the underlying data objects like tables and views that the space queries.
• D. Incorrect. Membership in the default `users` group does not inherently grant specific access to a Genie space or its data. Furthermore, a user does not need to be the owner of the underlying tables to view the data; they only need appropriate read permissions, such as SELECT.

Correct answer: B — The SQL warehouse attached to the Genie space must be restarted.

• A. Incorrect. The AI/BI Genie does not automatically detect schema changes in a timely or reliable manner. Relying on an automatic process can lead to delays and inconsistencies; an explicit, manual action is required to ensure the updated schema is recognized.
• B. Correct. AI/BI Genie relies on its attached SQL warehouse to query data and understand the underlying schema. SQL warehouses cache table metadata for performance. When a schema is altered directly in Unity Catalog, this cache can become stale. Restarting the SQL warehouse is the definitive method to clear its cache, forcing it to reload the latest schema from Unity Catalog and making the new column available to the Genie.
• C. Incorrect. The command used to add the column (`ALTER TABLE`) has already updated the table's metadata within Unity Catalog. The core issue is not the state of the metadata in the catalog itself, but rather the stale, cached version of that metadata held by the running SQL warehouse. Refreshing the metadata in the catalog again will not force the warehouse to update its cache.
• D. Incorrect. Cloning an entire Genie space is an inefficient and unnecessarily drastic action for a simple schema update. This process does not address the root cause, which is the stale metadata cache on the attached compute resource.

Correct answer: B — In the Genie Space's instructions, defining the mapping (e.g., 'item_status_cd 1 means In Stock, 2 means Backordered').

• A. Incorrect. While adding comments to columns in Unity Catalog is a best practice for data governance and documentation for developers, it is not the primary mechanism used by the Genie Space's natural language model to interpret user queries. These comments are not typically exposed directly for end-user query mapping.
• B. Correct. The Genie Space instructions are the designated area to provide specific context, hints, and definitions directly to the AI. Defining the mapping here is the most direct and effective method to enable the natural language interface to understand that 'In Stock' corresponds to `item_status_cd = 1`, making the experience more intuitive for users.
• C. Incorrect. The name of a SQL warehouse is simply an identifier for a compute resource. It has no relationship to the semantic meaning of the data within tables and does not influence how the Genie Space interprets column values.
• D. Incorrect. Trusted Assets are used to curate and promote entire data assets like tables or views to guide users toward reliable data sources. This feature is not designed for defining the meaning of individual values within a column and would be an impractical and inappropriate solution for this use case.

Correct answer: B — A central fact table containing transactional data, connected directly to a set of denormalized dimension tables.

• A. Incorrect. This description accurately defines a snowflake schema, not a star schema. In a snowflake schema, dimension tables are normalized into multiple, related tables, creating a more complex structure that requires more joins.
• B. Correct. This is the classic definition of a star schema. It consists of a central fact table containing quantitative or transactional data (measures), which is connected directly to a set of denormalized dimension tables that provide descriptive context. This simple, radial structure simplifies queries and improves performance.
• C. Incorrect. This describes the components of a Data Vault model. Data Vault is a modeling methodology that uses Hubs, Links, and Satellites to provide a flexible and auditable data integration layer, which is structurally different from a star schema.
• D. Incorrect. This describes a single, denormalized flat table or a wide table. While the dimension tables in a star schema are denormalized, the core principle of a star schema is the separation of facts and dimensions into distinct tables, not combining them into one.

Correct answer: C — The Silver layer, because it represents a cleaned and conformed version of the source data.

• A. Incorrect. The Gold layer contains highly refined, business-level aggregates and feature-engineered tables optimized for specific reporting and analytics use cases. While the `cleansed_transactions` table is validated and usable for analysis, it has not yet been aggregated into a final business-level view, so it does not belong in the Gold layer.
• B. Incorrect. The Bronze layer is the landing zone for raw, unprocessed source data, ingested without changes. Since this table has undergone significant transformations including joins, data type casting, and filtering, it has moved beyond the Bronze layer.
• C. Correct. The Silver layer is designed to store cleansed, conformed, and enriched data that serves as a single source of truth. The process described—joining raw data, correcting data types, and filtering for validity—is the exact definition of creating a Silver table.
• D. Incorrect. A Sandbox layer is typically used for ad-hoc exploration, development, or experimental work. A table intended to be a validated source for multiple downstream projects is a core part of the data architecture, not an experimental one.

Correct answer: B — USAGE

• A. Incorrect. The `SELECT` privilege grants permission to read data from tables and views. Granting this on a schema would allow users to query the data in all tables within that schema, which directly contradicts the requirement that they should not be able to read the data.
• B. Correct. In Unity Catalog, the `USAGE` privilege on a schema is required to access objects within that schema. It allows a user to see the existence of tables and views and to view their metadata (e.g., using `DESCRIBE TABLE`) without granting permissions to read or modify the underlying data. This is the most appropriate, least-privileged grant for the specified requirement.
• C. Incorrect. The `BROWSE` privilege is not a valid privilege for schemas in Databricks Unity Catalog. While a `BROWSE` privilege exists, it applies to external locations and storage credentials to allow browsing files, not to database objects like schemas or tables.
• D. Incorrect. The `MODIFY` privilege is overly permissive as it grants the ability to add, delete, and modify data in tables (i.e., `INSERT`, `UPDATE`, `DELETE`). This is unnecessary for the task of simply viewing metadata and poses a security risk.

Correct answer: B — Create a `prod` catalog and a `dev` catalog, each containing schemas named `raw_data` and `curated_data`.

• A. Incorrect. This approach places the environment distinction at the table level by prefixing table names, rather than using the higher levels of the namespace. It clutters the schema, complicates data management and security, and is not a recommended practice for environment separation in Unity Catalog.
• B. Correct. This is the recommended best practice for environment isolation in Unity Catalog. It leverages the top level of the 3-level namespace (catalog) to create a clear and robust separation, allowing identical schema and table names across environments (e.g., `prod.raw_data.orders` and `dev.raw_data.orders`), which simplifies security, governance, and CI/CD promotion pipelines.
• C. Incorrect. While technically possible, prefixing schema names is less clean and scalable than using separate catalogs. It clutters the schema namespace within a single catalog and does not fully utilize the organizational power of the 3-level namespace for environment isolation.
• D. Incorrect. The question asks how to use the 3-level namespace (`catalog.schema.table`) within Unity Catalog for separation. Using different metastores separates environments at a level above the 3-level namespace. While it provides isolation, it does not answer the question as asked and can make data promotion and sharing between environments more complex than using catalogs within a single metastore.