DP-600 domain - 27% of the exam

Implement and Manage Semantic Models

Implement and Manage Semantic Models is 27% of the DP-600 exam. These are the objectives it covers, each with practice questions, with every answer explained.

The domain in numbers

74
Practice questions
6
Objectives
11
Medium
63
Hard

Where people go wrong

  • Misreading how Direct Lake handles an unservable query

    The wrong answers describe what Direct Lake does with a query it cannot serve from the Delta columns as an outright error, blank visuals, a queue waiting for memory, or a full import of the table. With the default setting, only that one query falls back to DirectQuery through the SQL analytics endpoint. Results stay correct, that query loses in-memory speed, and other queries keep reading OneLake columns. An error is something the engineer must opt into.

    See it in a sample question
  • Treating Dual mode as a no-copy or always-fresh option

    The wrong answers offer Dual mode when the requirement is no duplicated data or the latest value at query time. Dual keeps an import cache, so it copies data into the model and can answer from that cache without reaching the source. It suits a shared dimension that joins both an import fact and a DirectQuery fact. When rows must stay in an external source database, DirectQuery leaves them there. For Delta tables in OneLake, Direct Lake gives in-memory speed with no copy and no scheduled refresh.

    See it in a sample question
  • Crediting large model storage format with other effects

    The wrong answers give the large semantic model storage format effects it lacks: moving the model out of memory, removing the size limit altogether, or delivering freshness and no duplication. The format keeps the model in import storage and raises the per-model ceiling from the small default toward the capacity maximum. Large models still load into shared capacity memory, so the capacity must be sized for the combined load. Freshness and no copying belong to Direct Lake.

    See it in a sample question
  • Fixing a row-by-row iterator with the wrong DAX tool

    The wrong answers reach for KEEPFILTERS, CALCULATETABLE or a calculated column when a measure is slow because the formula engine works row by row. KEEPFILTERS only changes how filters combine, and wrapping the same iterator in CALCULATETABLE leaves the work in the formula engine. A variable stops a repeated subexpression being evaluated twice, but the iterator still visits every row. A calculated column inflates the model and cannot react to slicers at query time. A column predicate inside CALCULATE lets VertiPaq run the work as a storage engine scan.

    See it in a sample question
  • Expecting column, table or relationship settings to shrink a VertiPaq model

    The wrong answers expect settings that describe a column, table or relationship to shrink the model: marking a date table, changing the summarisation property, bi-directional cross-filtering, or the Date data category. None of these changes how VertiPaq encodes the stored values. Size falls when cardinality and key width fall: a per-second datetime split into a date and a time, or a narrow integer surrogate key in place of a text code. Turning off Auto date/time removes the hidden date table built for each date column.

    See it in a sample question

Objectives in this domain

What to study

The official documents this domain's practice questions cite most.

Sample questions from this domain

Free sampleImplement and Manage Semantic Modelshard

A "Direct Lake" "semantic model" reads tables from a "Lakehouse". A report author adds a transformation that the "Direct Lake" engine cannot serve from the Delta files, and the model is configured so queries still return correct results. What happens to the affected queries, and what is the cost of this behaviour?

  • AThe queries fail and return an error until the author rewrites the report, because "Direct Lake" cannot fall back and every query must be served entirely from the Delta files in memory.
  • BThe queries are silently dropped from the report and show blank visuals, because "Direct Lake" skips any query it cannot serve from memory rather than sending it elsewhere.
  • CThe affected queries fall back to DirectQuery against the "SQL analytics endpoint" of the "Lakehouse", returning correct results but losing the in-memory performance of "Direct Lake" for those queries. Correct
  • DThe affected queries fall back to import mode by loading the whole table into the model, returning correct results but consuming model memory until the next scheduled refresh clears the cache.
Know that Direct Lake falls back to DirectQuery on the Lakehouse SQL analytics endpoint for unsupported queries, trading speed for correctness. Direct Lake serves queries from Delta files in memory, but when a query exceeds what that path supports it falls back to DirectQuery against the Lakehouse SQL analytics endpoint, which keeps results correct while running those specific queries at DirectQuery speed instead of the faster in-memory path.

Why A is wrong: Direct Lake does not simply error on unsupported queries when fallback is allowed; it has a defined fallback path, so claiming an outright failure misstates the engine's behaviour.

Why B is wrong: Direct Lake does not blank out unsupported visuals; it routes them through a fallback rather than dropping them, so blank visuals is not the documented outcome.

Why C is correct: When a query cannot be served from the Delta files, Direct Lake falls back to DirectQuery over the Lakehouse SQL analytics endpoint, so results stay correct but those queries run slower than the in-memory path.

Why D is wrong: Direct Lake does not fall back by importing entire tables on a refresh schedule; its fallback is a live DirectQuery to the SQL endpoint, not a cached import load.

Free sampleImplement and Manage Semantic Modelshard

A "semantic model" imports a large historical sales fact table that changes only with a nightly batch load. The same model must also expose a small inventory table whose rows are updated continuously in a source database, and reports must show the latest inventory value at query time. The team wants to keep import speed on sales while showing live inventory in one model. How should the model be configured?

  • ABuild a composite model that keeps the sales table in import mode and sets the inventory table to DirectQuery mode, so sales stays fast while inventory is read live at query time. Correct
  • BSet both the sales table and the inventory table to import mode, then schedule frequent refreshes so the imported inventory rows stay close enough to the live source values for reporting.
  • CSet both the sales table and the inventory table to DirectQuery mode, so every report query reaches the source and the historical sales aggregates always reflect live data alongside inventory.
  • DBuild a composite model that keeps the sales table in import mode and sets the inventory table to dual mode, so inventory is cached in memory yet still shown live whenever a report runs.
Use a composite model with import for slow-changing facts and DirectQuery for a live table when one model must mix cached speed and query-time freshness. Composite models let each table carry its own storage mode, so importing the nightly sales fact preserves in-memory aggregation speed while setting the volatile inventory table to DirectQuery sends its reads to the source at query time, returning the current value without forcing the whole model live.

Why A is correct: A composite model mixes storage modes per table, so import preserves sales performance while DirectQuery on the small inventory table returns the latest source value at query time, meeting both needs.

Why B is wrong: Frequent refresh narrows the gap but still serves cached inventory between runs, so reports cannot show the latest value at query time, which the requirement demands.

Why C is wrong: Making the slow-changing sales fact DirectQuery sacrifices the import speed the team wants and pushes heavy aggregation to the source, which is unnecessary for nightly batch data.

Why D is wrong: Dual mode can answer from its import cache, so it does not guarantee the latest inventory value at query time; it suits dimensions shared across import and DirectQuery facts, not live readings.

Free sampleImplement and Manage Semantic Modelsmedium

A data team runs several import "semantic models" on the same "Fabric" capacity. After enabling the large semantic model storage format on the biggest model, a colleague worries that one oversized model could starve the others of memory during refresh. The team wants the largest model to keep growing while protecting overall capacity stability. Which understanding of the format's effect on capacity memory is correct?

  • AEnabling the format grants the model unlimited memory, so capacity sizing no longer constrains how large that single model is allowed to become.
  • BThe format moves the model entirely to disk, so it consumes no capacity memory and cannot affect other models on the same capacity at all.
  • CThe format forces every other model on the capacity to also adopt the large format, multiplying total memory use across the whole workspace automatically.
  • DThe model can grow up to the capacity's maximum, but it still draws on shared capacity memory, so the SKU must be sized for the combined load. Correct
Understand that large-format models still consume shared capacity memory up to the SKU maximum, so the capacity must be sized for the combined load. The large semantic model storage format lifts the per-model size limit toward the capacity maximum, but the model is still loaded into the capacity's shared memory to serve queries and refreshes, so the SKU must be sized to hold the combined working set of all hosted models.

Why A is wrong: The format raises the per-model ceiling but the capacity SKU still bounds total memory, so the claim of unlimited growth misstates how capacity limits continue to apply.

Why B is wrong: Large-format models are still loaded into memory to be queried, so they do consume capacity memory and can compete with other models, making the disk-only claim wrong.

Why C is wrong: The format is set per model and does not cascade to other models, so enabling it on one model does not automatically reconfigure the rest of the capacity.

Why D is correct: Large-format models still load into the capacity's shared memory pool up to the SKU maximum, so right-sizing the capacity for the combined footprint is what protects the other models.

Free sampleImplement and Manage Semantic Modelshard

A measure that totals sales for high-value orders is slow on a wide fact table. Profiling shows most time in the formula engine because the author wrapped the whole fact table in FILTER and passed it to CALCULATE. The team wants the same result computed mostly inside the VertiPaq storage engine. Which rewrite of the measure is the most effective?

Slow = CALCULATE(SUM('Sales'[Amount]), FILTER('Sales', 'Sales'[Amount] > 1000))
  • AReplace the table FILTER with a column predicate, writing CALCULATE(SUM('Sales'[Amount]), 'Sales'[Amount] > 1000), so the filter and the sum run as one storage engine scan. Correct
  • BKeep the FILTER over the whole table but wrap it in KEEPFILTERS, so the existing filter context is preserved and the engine evaluates the table scan in parallel across threads.
  • CMove the FILTER into a VAR declared once and reference that variable inside CALCULATE, so the filtered table is built a single time and the storage engine reuses it.
  • DConvert the measure into a calculated column that flags high-value rows, then sum the flagged column, so the per-row test runs at refresh and the visual reads the result.
Replace a table-level FILTER with a column predicate in CALCULATE so VertiPaq filters and aggregates in one scan. Passing FILTER over an entire fact table forces the formula engine to materialise and iterate the row set, which is the bottleneck; a column predicate such as 'Sales'[Amount] > 1000 inside CALCULATE is pushed to VertiPaq, which applies the filter and the SUM together as a single columnar scan and avoids the expensive table materialisation.

Why A is correct: A column predicate in CALCULATE lets VertiPaq apply the threshold and the aggregation in a single columnar scan, removing the formula engine materialisation of the full table that FILTER over the whole fact table forced.

Why B is wrong: KEEPFILTERS only governs how the filter combines with outer context and does not remove the table-level FILTER, so the formula engine still materialises the row set and the measure stays slow.

Why C is wrong: Capturing the filtered table in a VAR avoids rebuilding it twice but still forces the formula engine to materialise the whole table row set, so the underlying table-scan cost that profiling flagged remains.

Why D is wrong: A calculated column materialises a value per row and inflates model size, and it cannot react to a threshold chosen by a slicer at query time, so it changes behaviour rather than safely optimising the measure.

Free sampleImplement and Manage Semantic Modelshard

Using "VertiPaq Analyzer" on a large import "semantic model", an engineer finds one column consuming a disproportionate share of total model size. It is a high-precision datetime column on the fact table that stores both date and time to the second, and it is used only to join to a date dimension at day grain. Which change reduces this column's footprint the most while preserving the required analysis?

  • AMark the datetime column as a date table key and enable the model date hierarchy, so the engine indexes the column and stores it more compactly for time intelligence.
  • BSet the column's summarisation to do not summarise, so the engine stops building aggregate structures over it and the stored column shrinks accordingly.
  • CSort the fact table by the datetime column before import, so run-length encoding compresses the now-ordered timestamps and the column occupies far less memory.
  • DSplit the datetime column into a date column and a separate time column, so the model keeps both parts and the engine can compress the two narrower columns independently. Correct
Lower a datetime column's cardinality by splitting it into date and time parts to shrink the VertiPaq dictionary. VertiPaq size is driven largely by column cardinality, which sets the dictionary size; a per-second datetime has millions of distinct values, so splitting it into a day-grain date column and a separate time column collapses the dominant dictionary while keeping both date joins and any time-of-day analysis available.

Why A is wrong: Marking a date table and adding a hierarchy supports time intelligence but does not lower the underlying per-second cardinality, so the oversized dictionary and the column footprint remain unchanged.

Why B is wrong: The default summarisation property affects how the column behaves in visuals, not how VertiPaq encodes or sizes the stored values, so changing it has no effect on the column footprint.

Why C is wrong: Sort order can help run-length encoding, but a per-second timestamp still has very high cardinality, so the dictionary stays large and sorting alone gives only marginal savings here.

Why D is correct: Splitting a high-cardinality datetime into a low-cardinality date key and a separate time column shrinks the dictionary that dominated size, because day-grain dates have far fewer distinct values than per-second timestamps.

Other domains in this exam

See also the DP-600 cert hub, the study guide, and the cheat sheet.

Examworthy is not affiliated with or endorsed by Microsoft. Original, blueprint-aligned practice material only.