Pass Your Microsoft DP-600 Exam Easy!

This action is appropriate when a Spark transformation filters by local server date instead of UTC event date and drops midnight transactions. Date filters need consistent event-time interpretation. However, the question instead requires Project only the approved columns and apply data security to the source. because column minimization reduces data movement but does not replace authorization.

This action is appropriate when a dataflow uses a case-sensitive comparison but source statuses differ only by capitalization. String matching must reflect the source's expected case rules. However, the question instead requires Project only the approved columns and apply data security to the source. because column minimization reduces data movement but does not replace authorization.

This action is appropriate when a SQL WHERE condition combines `AND` and `OR` and incorrectly includes unapproved customer types. Operator precedence can change which records are selected. However, the question instead requires Project only the approved columns and apply data security to the source. because column minimization reduces data movement but does not replace authorization.

This action is appropriate when a historical backfill starts before the current CDC watermark and overwrites newer target values. Backfill and incremental replay require a consistent ordering contract. However, the question instead requires Use idempotent merge logic and persisted source progress state. because replay safety protects business totals from duplicate side effects.

This action is appropriate when an upsert receives a delete event but the target table retains the obsolete row. Inserts and updates alone cannot represent removals from the source. However, the question instead requires Use idempotent merge logic and persisted source progress state. because replay safety protects business totals from duplicate side effects.

This action is appropriate when a warehouse MERGE update uses an ambiguous business key shared by independent vendors. Cross-source identifiers may collide without provenance. However, the question instead requires Use idempotent merge logic and persisted source progress state. because replay safety protects business totals from duplicate side effects.

This action is appropriate when a team writes a `CREATE TABLE AS SELECT` query against a lakehouse SQL analytics endpoint and expects a writable warehouse. Read-oriented SQL analytics endpoints and warehouse SQL authoring have different write capabilities. However, the question instead requires Use a lakehouse notebook and PySpark transformation path. because spark is suited to programmatic distributed processing of semi-structured tables.

This action is appropriate when an ETL job produces Delta tables through Spark but analysts need read-only T-SQL exploration. The SQL endpoint exposes tabular Delta data to SQL consumers without changing the Spark ingestion path. However, the question instead requires Use a lakehouse notebook and PySpark transformation path. because spark is suited to programmatic distributed processing of semi-structured tables.

This action is appropriate when a business wants one published gold table and two engineering teams each materialize inconsistent transformations. A controlled serving contract prevents divergent downstream reporting definitions. However, the question instead requires Use a lakehouse notebook and PySpark transformation path. because spark is suited to programmatic distributed processing of semi-structured tables.

This action is appropriate when a team assumes a saved visual query is a durable physical table snapshot. An interactive query definition does not itself guarantee stored historical data. However, the question instead requires Add a grouped aggregate in the Visual query editor. because grouping and aggregation can be composed visually for common analytical questions.

This action is appropriate when a graphical query returns unexpected rows because a filter was applied to the wrong field. Visual authoring still requires checking the effective predicate semantics. However, the question instead requires Add a grouped aggregate in the Visual query editor. because grouping and aggregation can be composed visually for common analytical questions.

This action is appropriate when an analyst wants to compare two governed tables interactively without copying either into Excel. Visual queries can combine supported sources while retaining governed execution. However, the question instead requires Add a grouped aggregate in the Visual query editor. because grouping and aggregation can be composed visually for common analytical questions.

This action is appropriate when a SQL result displays individual product names but uses SUM without grouping them. Nonaggregated selected columns must be compatible with the grouping semantics. However, the question instead requires Use GROUP BY followed by HAVING on the aggregate. because hAVING filters grouped results rather than individual source rows.

This action is appropriate when a query needs unique regions represented in a customer table rather than every repeated row. DISTINCT collapses duplicate selected tuples and can answer basic dimensional questions. However, the question instead requires Use GROUP BY followed by HAVING on the aggregate. because hAVING filters grouped results rather than individual source rows.

This action is appropriate when a report needs the ten largest revenue customers after aggregation. Ranking and limiting should occur after the relevant grouping calculation. However, the question instead requires Use GROUP BY followed by HAVING on the aggregate. because hAVING filters grouped results rather than individual source rows.

This action is appropriate when a SQL analyst wants each region's contribution percentage of all revenue while retaining region rows. Window totals provide denominators without a separate cross join. However, the question instead requires Use ROW_NUMBER over order partitions with a deterministic descending timestamp and tie-breaker. because window ranking identifies a stable preferred row in each business group.

This action is appropriate when a product manager needs current-month revenue compared with the prior month in SQL. Window offset functions compare adjacent ordered summary periods. However, the question instead requires Use ROW_NUMBER over order partitions with a deterministic descending timestamp and tie-breaker. because window ranking identifies a stable preferred row in each business group.

This action is appropriate when a report accidentally uses ROW_NUMBER without ordering and declares results reproducible. Ranking needs deterministic sort criteria for reproducible selections. However, the question instead requires Use ROW_NUMBER over order partitions with a deterministic descending timestamp and tie-breaker. because window ranking identifies a stable preferred row in each business group.

This action is appropriate when an event query returns case-mismatched service names and the analyst uses the wrong KQL string operator. KQL string operators encode case semantics that affect matching. However, the question instead requires Apply KQL `project` to select the required fields. because projection reduces irrelevant columns and improves output readability.

This action is appropriate when a telemetry table contains a JSON-like dynamic property bag and users need its error code. KQL dynamic fields require typed access for reliable filtering and aggregation. However, the question instead requires Apply KQL `project` to select the required fields. because projection reduces irrelevant columns and improves output readability.

This action is appropriate when an analyst tries to execute T-SQL `SELECT TOP` syntax directly in a KQL-only query interface. KQL has a different query language and pipeline syntax from T-SQL. However, the question instead requires Apply KQL `project` to select the required fields. because projection reduces irrelevant columns and improves output readability.

This action is appropriate when a KQL timeseries chart is missing zero-activity intervals and stakeholders infer no time passed. Event-driven summaries may omit periods with no input events. However, the question instead requires Apply KQL summarize with `avg()` and a one-hour time bin per device. because combining time bins and device groups yields meaningful time-series summaries.

This action is appropriate when a query shows a spike but the team needs to exclude missing measurement values from its mean. Bad input records can distort aggregated sensor statistics. However, the question instead requires Apply KQL summarize with `avg()` and a one-hour time bin per device. because combining time bins and device groups yields meaningful time-series summaries.

This action is appropriate when an analyst wants to compare each day's failure rate rather than only total failures. A rate needs an explicit population denominator and numeric type handling. However, the question instead requires Apply KQL summarize with `avg()` and a one-hour time bin per device. because combining time bins and device groups yields meaningful time-series summaries.

This action is appropriate when a manager wants revenue share by category relative to all visible categories. Percent of visible total needs a deliberate denominator filter context. However, the question instead requires Use CALCULATE with an explicit channel filter and validate filter interaction. because cALCULATE modifies evaluation context to constrain the measure.

This action is appropriate when a DAX measure sums each row's price times quantity but the fact table has no precomputed extended amount. An iterator calculates expressions per row before aggregating. However, the question instead requires Use CALCULATE with an explicit channel filter and validate filter interaction. because cALCULATE modifies evaluation context to constrain the measure.

This action is appropriate when a user filters the report to one year and a measure unexpectedly ignores the year slicer. DAX context modification can erase necessary report filters. However, the question instead requires Use CALCULATE with an explicit channel filter and validate filter interaction. because cALCULATE modifies evaluation context to constrain the measure.

This action is appropriate when a DAX expression counts customers after a filter but an engineer uses COUNT on a nonnumeric text field incorrectly. Counting rows and counting unique business entities are distinct analytical operations. However, the question instead requires Inspect the filter propagation paths and any ALL or REMOVEFILTERS calls. because incorrect context or relationship direction can prevent row-level dimensional filters.

This action is appropriate when a calculation needs a dimension value from the related one-side table for each fact row. RELATED relies on relationships and row context rather than arbitrary text matching. However, the question instead requires Inspect the filter propagation paths and any ALL or REMOVEFILTERS calls. because incorrect context or relationship direction can prevent row-level dimensional filters.

This action is appropriate when a report contains two date relationships, one active and one inactive, and needs shipping-date revenue. Explicit relationship activation selects the intended date path for a measure. However, the question instead requires Inspect the filter propagation paths and any ALL or REMOVEFILTERS calls. because incorrect context or relationship direction can prevent row-level dimensional filters.

This action is appropriate when a Power BI analyst wants a KPI evaluated under report slicers and semantic model relationships. DAX understands model filter context and report interactions. However, the question instead requires Choose KQL queries against the KQL database. because kQL is optimized for event-stream and time-series analysis patterns.

This action is appropriate when a team tries to run a DAX `CALCULATE` expression as if it were a Fabric warehouse stored procedure. Model measure expressions are not interchangeable with T-SQL stored procedures. However, the question instead requires Choose KQL queries against the KQL database. because kQL is optimized for event-stream and time-series analysis patterns.

This action is appropriate when a developer copies a SQL `GROUP BY` query directly into KQL and gets parser errors. Equivalent analytical goals use distinct language operators across engines. However, the question instead requires Choose KQL queries against the KQL database. because kQL is optimized for event-stream and time-series analysis patterns.