DP-600 Implementing Analytics Solutions Using Microsoft Fabric Questions and Answers

The PoC is planned to be completed using a Fabric trial capacity, which implies that users involved in the PoC should be able to try paid features. However, this should be limited to specific security groups involved in the PoC to prevent the entire organization from accessing these features before the trial is proven successful (A). The ability for users to create Fabric items should also be enabled for specific security groups to ensure that only the relevant team members participating in the PoC can create items in the Fabric environment (E).

Both a dataflow (A) and a Stored procedure activity in a pipeline (B) are capable of creating and populating a date dimension table. A dataflow can perform the transformation needed to create the date dimension, and it aligns with the preference for using low-code tools for data ingestion when possible. A Stored procedure could be written to generate the necessary date dimension data and executed within a pipeline, which also adheres to the technical requirements for the PoC.

For ingesting customer data into the data store in the AnalyticsPOC workspace, a dataflow (D) should be recommended. Dataflows are designed within the Power BI service to ingest, cleanse, transform, and load data into the Power BI environment. They allow for the low-code ingestion and transformation of data as needed by Litware ' s technical requirements. References = You can learn more about dataflows and their use in Power BI environments in Microsoft ' s Power BI documentation.

 The issue is that USERNAME() is returning blank in Fabric because it needs the user principal name (UPN) from Microsoft Entra ID.

 Simply creating a role in the model does not fix the problem of the identity not being surfaced.

 To solve this, you need to ensure that the Entra UPN is synced correctly (via Entra Connect attribute mappings) and use the right function (USERPRINCIPALNAME() in modern models).

 Therefore, just creating a role does not meet the goal.

For the semantic model design required for the customer satisfaction report, the choices for data source authentication method and mode should be made based on security and performance considerations as per the case study provided.

Authentication method: The data should be accessed securely, and given that row-level security (RLS) is required for users executing T-SQL queries, you should use an authentication method that supports RLS. Service principal authentication is suitable for automated and secure access to the data, especially when the access needs to be controlled programmatically and is not tied to a specific user ' s credentials.

Mode: The report needs to show data as soon as it is updated in the data store, and it should only contain data from the current and previous year. DirectQuery mode allows for real-time reporting without importing data into the model, thus meeting the need for up-to-date data. It also allows for RLS to be implemented and enforced at the data source level, providing the necessary security measures.

Based on these considerations, the selections should be:

Authentication method: Service principal authentication

Mode: DirectQuery

To meet the technical requirement that data loading activities must ensure the raw and cleansed data is updated completely before populating the dimensional model, you would need a mechanism that allows for ordered execution. A pipeline in Microsoft Fabric with dependencies set between activities can ensure that activities are executed in a specific sequence. Once set up, the pipeline can be scheduled to run at the required intervals (hourly or daily depending on the data source).

The Direct Lake fallback behavior is set to: DirectQueryOnly

The query for the table visual is executed by using: DirectQuery

In the context of Microsoft Power BI, when using DirectQuery in Direct Lake mode, there is no caching of data and all queries are sent directly to the underlying data source. The Performance Analyzer tool shows the time taken for different operations, and from the options provided, it indicates that DirectQuery mode is being used for the visuals, which is consistent with the Direct Lake setting. DirectQueryOnly as the fallback behavior ensures that only DirectQuery will be used without reverting to import mode.

User-defined aggregations (A) and query caching (C) are two features that can help reduce query execution time. User-defined aggregations allow precalculation of large datasets, and query caching stores the results of queries temporarily to speed up future queries. References = Microsoft Power BI documentation on performance optimization offers in-depth knowledge on these features.

DF1 will be deployed to Workspace_TEST: Yes

Data from Model1 will be deployed to Workspace_TEST: No

The scheduled refresh policy for Model1 will be deployed to Workspace_TEST: No

DF1 is a Dataflow Gen1 with a configured scheduled refresh policy, so it will be deployed to Workspace_TEST.

Data from Model1 will not be deployed as Model1 ' s scheduled refresh policy is not configured, indicating it is not set up for deployment.

The scheduled refresh policy for Model1 will not be deployed since it is listed as " Not configured. "

We are optimizing model1 in Fabric with two very large columns:

TransactionKey

Cardinality: 2.5 billion

Size: 160 GB

Description: surrogate key for SalesTransaction fact table.

SaleDateTime

Cardinality: 6.8 million

Size: 120 GB

Description: datetime (to the second) of when a sale occurred.

Goal:

Reduce model size.

Improve refresh performance (Import mode).

Ensure datetime values remain available.

Analysis per column

1. TransactionKey (very high cardinality)

Surrogate keys with extremely high cardinality do not add analytical value in a semantic model because they are not used in measures or grouping.

They take a lot of memory and reduce refresh performance.

Best practice: remove the column from the model.

2. SaleDateTime

Needed to analyze transactions by date and time.

However, storing the full datetime at second-level cardinality causes huge memory usage.

To optimize: split the column into Date and Time columns.

Reduces cardinality significantly.

Preserves full datetime information (can recombine if needed).

Improves compression and refresh speed.

Final Answer:

TransactionKey: Remove the column.

SaleDateTime: Split the column.

For the Customers table, where the requirement is to create a new version of the row, you would use:

Type 2 SCD: This type allows for the creation of a new record each time a change occurs, preserving the history of changes over time.

For the Products table, where the requirement is to overwrite the existing value in the latest row, you would use:

Type 1 SCD: This type updates the record directly, without preserving historical data.

Workspace_DEV contents:

Lakehouse1, Notebook1, Pipeline1, SemanticModel1

Workspace_TEST contents (before deployment):

Lakehouse2, Notebook2, SemanticModel1

After deployment:

SemanticModel1 → same name, so it will be paired and overwritten with the DEV version.

Lakehouse1 and Notebook1 → new items, so they will be added to TEST.

Lakehouse2 and Notebook2 → remain because they don’t conflict in name.

Pipeline1 → new item, so it will also be added.

So the final content is:

Lakehouse1, Lakehouse2, Notebook1, Notebook2, Pipeline1, SemanticModel1

Answer: B

Comprehensive Detailed Explanation

We need to query a KQL database table named Readings to generate output that includes both the current reading and the previous reading values and datetime for each row.

Step 1: Understanding Requirements

The output table shows:

City, Area, MeterReading, Datetime

PrevMeterReading, PrevDatetime

The prev() function in KQL is used to access the value of a column from the previous row (based on order).

Step 2: Query Construction

We start with filtering:

Readings

| where City == " Copenhagen "

| sort by Datetime

To add columns that calculate the previous reading and previous datetime, we use extend:

| extend PrevMeterReading = prev(MeterReading), PrevDatetime = prev(Datetime)

extend creates new columns.

prev() pulls the previous row’s values.

Finally, we only want specific columns in the output. For this, we use project:

| project City, Area, MeterReading, Datetime, PrevMeterReading, PrevDatetime

Step 3: Completed Query

Readings

| where City == " Copenhagen "

| sort by Datetime

| extend PrevMeterReading = prev(MeterReading), PrevDatetime = prev(Datetime)

| project City, Area, MeterReading, Datetime, PrevMeterReading, PrevDatetime

Why This is Correct

extend adds calculated columns.

prev() gives access to the previous row.

project selects only the required columns.

This matches exactly the table shown in the question.

References

Kusto Query Language - extend operator

Kusto Query Language - project operator

prev() function in KQL

In a Fabric Data Factory pipeline, to execute a stored procedure and make the returned values available for downstream activities, the Lookup activity is used. This activity can retrieve a dataset from a data store and pass it on for further processing. Here’s how you would use the Lookup activity in this context:

Add a Lookup activity to your pipeline.

Configure the Lookup activity to use the stored procedure by providing the necessary SQL statement or stored procedure name.

In the settings, specify that the activity should use the stored procedure mode.

Once the stored procedure executes, the Lookup activity will capture the results and make them available in the pipeline’s memory.

Downstream activities can then reference the output of the Lookup activity.

The Table.Max function should be used in a Power Query step to identify the maximum values for the numeric columns. This function is designed to calculate the maximum value across each column in a table, which suits the requirement of finding maximum values for numeric columns. References = For detailed information on Power Query functions, including Table.Max, please refer to Power Query M function reference.

Step 1: Requirement

We need to calculate total sales amount by OrderDate.

Total Sales Amount = Quantity × UnitPrice per row.

Then SUM over all rows per OrderDate.

Only include rows where the OrderDate matches a public holiday in Australia.

Step 2: Calculation Logic

If we select s.Quantity * s.UnitPrice, it only computes row-level values.

To calculate the total sales amount per OrderDate, we need:

SUM(s.Quantity * s.UnitPrice) AS TotalSalesAmt

Thus, the correct calculation: SUM(s.Quantity * s.UnitPrice)

Step 3: Join Type

We want to return only those sales that occurred on public holidays in Australia.

If we used a LEFT JOIN, we’d include all sales regardless of holiday.

A FULL OUTER JOIN would include non-matching rows, not required.

A CROSS JOIN would duplicate results unnecessarily.

A RIGHT OUTER JOIN would include holidays with no sales, which is not needed.

The correct choice is an INNER JOIN on matching dates.

Step 4: Final Query

SELECT

s.OrderDate,

SUM(s.Quantity * s.UnitPrice) AS TotalSalesAmt

FROM dbo.sales AS s

INNER JOIN dbo.publicholidays AS ph

ON s.OrderDate = ph.Date

WHERE ph.countryOrRegion = ' Australia '

GROUP BY s.OrderDate;

Why This is Correct

SUM(s.Quantity * s.UnitPrice) → ensures sales are aggregated correctly.

INNER JOIN → ensures only rows where OrderDate matches a holiday are included.

WHERE ph.countryOrRegion = ' Australia ' → filters holidays to Australia only.

References

SUM (Transact-SQL)

JOIN operations in T-SQL

Comprehensive Detailed Explanation

Workspace Roles in Microsoft Fabric (same as Power BI workspaces):

Viewer

Can only read/view content.

Cannot create or edit.

Contributor

Can create and write data (datasets, reports, semantic models).

Cannot manage permissions or workspace settings.

Member

Can create and edit content.

Can also add/remove people to the workspace (except Admins).

Cannot delete the workspace itself.

Admin

Full control: can configure settings, add/remove members, and delete the workspace.

Step 1: Group1 Requirements

Must be able to write data.

Must NOT be able to add members.

→ Contributor (can write but cannot manage membership).

Step 2: Group2 Requirements

Must be able to configure and maintain workspace settings.

→ Only Admin role allows configuring workspace-level settings.

→ Admin.

Step 3: Group3 Requirements

Must be able to write data.

Must be able to add members.

Must NOT be able to delete the workspace.

→ This matches the Member role.

For the HighestSellingPrice, you should use the GREATEST function to find the highest value from the given price columns. However, T-SQL does not have a GREATEST function as found in some other SQL dialects, so you would typically use a CASE statement or an IIF statement with nested MAX functions. Since neither of those are provided in the options, you should select MAX as a placeholder to indicate the function that would be used to find the highest value if combining multiple MAX functions or a similar logic was available.

For the TradePrice, you should use the COALESCE function, which returns the first non-null value in a list. The COALESCE function is the correct choice as it will return AgentPrice if it ' s not null; if AgentPrice is null, it will check WholesalePrice, and if that is also null, it will return ListPrice.

The complete code with the correct SQL functions would look like this:

SELECT ProductID,

MAX(ListPrice, WholesalePrice, AgentPrice) AS HighestSellingPrice, -- MAX is used as a placeholder

COALESCE(AgentPrice, WholesalePrice, ListPrice) AS TradePrice

FROM Sales.Products

Select MAX for HighestSellingPrice and COALESCE for TradePrice in the answer area.

The Vertipaq Analyzer tool (B) and querying the $system.discovered_STORAGE_TABLE_COLUMNS_IN_SEGMENTS dynamic management view (DMV) (C) can help identify which columns are frequently loaded into memory. Both methods provide insights into the storage and retrieval aspects of the semantic model. References = The Power BI documentation on Vertipaq Analyzer and DMV queries offers detailed guidance on how to use these tools for performance analysis.

The Spark engine will read only the ' SalesOrderNumber ' , ' OrderDate ' , ' CustomerName ' , ' UnitPrice ' columns from Sales_raw.csv. - Yes

Removing the partition will reduce the execution time of the query. - No

Adding inferSchema= ' true ' to the options will increase the execution time of the query. - Yes

The code specifies the selection of certain columns, which means only those columns will be read into the DataFrame. Partitions in Spark are a way to optimize the execution of queries by organizing the data into parts that can be processed in parallel. Removing the partition could potentially increase the execution time because Spark would no longer be able to process the data in parallel efficiently. The inferSchema option allows Spark to automatically detect the column data types, which can increase the execution time of the initial read operation because it requires Spark to read through the data to infer the schema.

GRANT ALTER ON SCHEMA::schemaA TO User1;

The ALTER permission allows a user to modify the schema of an object, and granting ALTER on a schema will allow the user to perform operations like TRUNCATE TABLE on any object within that schema. It is the correct permission to grant to User1 for truncating tables in schemaA.

References =

GRANT Schema Permissions

Permissions That Can Be Granted on a Schema

Comprehensive Detailed Explanation

When assigning permissions to roles in a Fabric workspace for analytics workloads, you must align permissions with the responsibilities and tools typically used by each persona:

1. Data Engineers

Their primary tasks include building and transforming data pipelines, as well as making datasets usable by others.

The appropriate permission is Build Reports on the default dataset, because this allows them to create and manage reports using the curated semantic model while preparing data for analysts and scientists.

2. Data Analysts

Analysts work heavily with Apache Spark for exploratory analysis, cleansing, and shaping data.

The correct permission is Read All Apache Spark, as this grants them the ability to query and analyze Spark-based data directly without elevated permissions that are unnecessary for their role.

3. Data Scientists

Data scientists often use SQL analytics endpoints to run queries, train models, and integrate data into machine learning workflows.

The correct permission is Read All SQL analytics endpoint data, since it enables direct programmatic access to the SQL endpoint, which is needed for advanced modeling and experimentation.

Summary of Selections:

DataEngineers → Build Reports on the default dataset

DataAnalysts → Read All Apache Spark

DataScientists → Read All SQL analytics endpoint data

References (Microsoft Fabric – DP-600 exam scope):

Workspace roles and permissions in Microsoft Fabric

SQL analytics endpoint in Fabric

Apache Spark in Microsoft Fabric

Requirement: “The number of rows added to the Orders table during refreshes must be minimized.”

The Orders table has a sequential OrderID.

To minimize refresh size, you must only import new rows, not the entire table.

This requires retrieving the maximum OrderID currently loaded, then only loading rows with a greater OrderID.

So, the correct solution is to use a pipeline (ADF) with a dataflow to retrieve the maximum OrderID.

Answer: C. an Azure Data Factory pipeline that executes a dataflow to retrieve the maximum value of the OrderID column in the destination lakehouse

Comprehensive Detailed Explanation

The requirement is to logically group the Research division workspaces and support filtering in the OneLake data hub.

Why Domain?

Microsoft Fabric allows you to assign workspace domains (e.g., Finance, HR, Research).

This provides a logical grouping of workspaces within the organization.

Domains are the only supported way to enable filtering in OneLake data hub by department.

Capacity or tenant grouping would not allow filtering by department in OneLake.

Why OneLake data hub?

The OneLake data hub is the centralized interface to browse and discover data assets across the organization.

With workspace domains configured, users can filter directly in the OneLake data hub by domain (e.g., “Research”).

The Fabric Admin portal and Entra admin center are used for administration, not for workspace filtering in data discovery.

Correct Selection for the Hotspot

Grouping method: Domain

Tool: OneLake data hub

References

Workspace domains in Microsoft Fabric

Discover and filter data in OneLake data hub

Final Answer:

Grouping method = Domain

Tool = OneLake data hub

Comprehensive Detailed Explanation

From the case study:

Research division data for Productline2 is currently in CSV format in storage2.

Requirement: “All the Research division data in the lakehouses must be presented as managed tables in Lakehouse explorer.”

In Fabric lakehouses, managed tables are stored in Delta format inside the Tables folder.

Step 1: Reading the source

df = spark.read.format( " csv " ) \

options(header= " true " , inferSchema= " true " ) \

load( " abfss://storage1.dfs.core.windows.net/files/productline2 " )

This correctly ingests the CSV source from ADLS Gen2.

Step 2: Writing to Lakehouse as a managed table

You must write the data in Delta format to ensure it is queryable and managed within the lakehouse.

The correct path is under Tables/, because this is where Fabric automatically manages Lakehouse managed tables.

The target table should be named productline2, so the correct path is:

df.write.mode( " overwrite " ).format( " delta " ).save( " Tables/productline2 " )

Why not other options?

CSV or Parquet formats would not create a managed Lakehouse table; they would just create files.

Writing to productline2 directly (without Tables/) would store unmanaged files in the Lakehouse Files area, not managed tables.

Writing to Tables/research/productline2 adds an unnecessary subdirectory and is not the standard structure for managed tables.

Correct Final Code

df.write.mode( " overwrite " ).format( " delta " ).save( " Tables/productline2 " )

References

Managed tables in Microsoft Fabric Lakehouse

Delta Lake support in Fabric

Spark write to Lakehouse

In Azure DevOps workspace (project) security settings, role assignments determine access levels for groups:

Viewer (equivalent to the Readers security group): Grants read-only access to work items, code, pipelines, and other artifacts. Ideal for review-only scenarios where users need to view but not edit content.

Contributor (equivalent to the Contributors security group): Allows full edit and contribute privileges, such as updating work items, code reviews, and pipeline runs. Suitable for active participation in reviews that may involve feedback or changes.

Based on the group names implying review-focused access, Viewer fits Group1 for passive observation, while Contributor fits Group2 for interactive review tasks. These align with default Azure DevOps permissions for secure, least-privilege access.

You need to recommend which type of Fabric capacity SKU meets the data analytics requirements for the Research division.

Requirement: “The Research division workspaces must use a dedicated, on-demand capacity that has per-minute billing.”

Fabric capacity SKUs:

F (Fabric) = dedicated Fabric capacity, available on pay-as-you-go with per-minute billing.

P (Premium) and EM are Power BI capacities (not Fabric-native).

A refers to Azure Analysis Services capacity.

The only correct option is F SKU.

 Calculation groups are a Tabular Object Model (TOM) feature.

 They cannot be authored in Power BI Desktop or the service.

 They are implemented using Tabular Editor.

You need to ensure that Contoso can use version control to meet the data analytics requirements and the general requirements.

Requirement: “All the semantic models and reports for the Research division must use version control that supports branching.”

Fabric supports Git integration (Azure Repos or GitHub) for semantic models and reports.

Storing in Data Lake Gen2 or OneDrive does not provide version control with branching.

The correct action is to integrate workspaces with a Git repository.

Answer: D. Modify the settings of the Research division workspaces to use an Azure Repos repository.

Comprehensive Detailed Explanation

The question asks: Which syntax should you use in a Fabric notebook to access the Research division data for Productline1?

Key Background from the Case

In Productline1ws, a lakehouse named Lakehouse1 is created.

In Lakehouse1, a shortcut is created to storage1, named ResearchProduct.

Storage1 contains the Research division data for Productline1 in Delta format.

Requirement: All data in lakehouses must be presented as managed tables in Lakehouse explorer.

Analyzing the Syntax Options

Option A:

spark.sql( " SELECT * FROM Lakehouse1.ResearchProduct " )

This syntax directly queries the ResearchProduct shortcut within Lakehouse1 using Spark SQL.

Since the shortcut points to Delta data, Spark can directly query it.

This is the correct way to retrieve Productline1 data from Lakehouse1.

Option B:

spark.sql( " SELECT * FROM Lakehouse1.productline1.ResearchProduct " )

This introduces an extra schema-like path (productline1) that is not part of the shortcut name.

Incorrect, because the shortcut was created as ResearchProduct inside Lakehouse1, not under another schema.

Option C:

external_table( ' Tables/ResearchProduct ' )

external_table is not the correct way to access a Lakehouse shortcut.

Shortcuts in Lakehouses appear as tables and can be queried using Spark SQL directly.

Option D:

spark.sql( " SELECT * FROM Lakehouse1.productline1.ResearchProduct " )

Same issue as Option B, includes a schema path that does not exist.

Correct Choice

Since the shortcut to ResearchProduct was created inside Lakehouse1, and Spark SQL can query it directly, the correct syntax is:

spark.sql( " SELECT * FROM Lakehouse1.ResearchProduct " )

That matches Option A.

References

Microsoft Fabric Lakehouse – Shortcuts

Query data in a lakehouse using Spark SQL

Delta format support in Microsoft Fabric