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 Push an appropriate date filter before expensive joins and aggregation. because early predicate filtering reduces unnecessary input processing.

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 Push an appropriate date filter before expensive joins and aggregation. because early predicate filtering reduces unnecessary input processing.

This action is appropriate when a report exposes restricted PII columns when analysts need only revenue totals. Column minimization reduces data movement but does not replace authorization. However, the question instead requires Push an appropriate date filter before expensive joins and aggregation. because early predicate filtering reduces unnecessary input processing.

This action is appropriate when a pipeline restarts after a partial failure and applies the same incremental batch twice. Replay safety protects business totals from duplicate side effects. However, the question instead requires Use a governed MERGE or supported CDC apply pattern keyed by source identity. because update-aware processing preserves the current entity state.

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 a governed MERGE or supported CDC apply pattern keyed by source identity. because update-aware processing preserves the current entity state.

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 a governed MERGE or supported CDC apply pattern keyed by source identity. because update-aware processing preserves the current entity state.

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 Run the transformation in the Fabric warehouse SQL environment. because warehouses expose supported relational SQL objects for analytics workflows.

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 Run the transformation in the Fabric warehouse SQL environment. because warehouses expose supported relational SQL objects for analytics workflows.

This action is appropriate when a researcher wants Python and Spark operations over large nested Delta data. Spark is suited to programmatic distributed processing of semi-structured tables. However, the question instead requires Run the transformation in the Fabric warehouse SQL environment. because warehouses expose supported relational SQL objects for analytics workflows.

This action is appropriate when a data consumer needs the sum of invoiced revenue grouped by product category through a GUI. Grouping and aggregation can be composed visually for common analytical questions. However, the question instead requires Use the supported Visual query editor to apply interactive filters. because the visual query interface can build supported queries without hand-authored syntax.

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 Use the supported Visual query editor to apply interactive filters. because the visual query interface can build supported queries without hand-authored syntax.

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 Use the supported Visual query editor to apply interactive filters. because the visual query interface can build supported queries without hand-authored syntax.

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 Apply the date condition in SQL WHERE before GROUP BY. because wHERE filters source rows prior to aggregation.

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 Apply the date condition in SQL WHERE before GROUP BY. because wHERE filters source rows prior to aggregation.

This action is appropriate when a manager wants departments with total sales above an aggregate threshold. HAVING filters grouped results rather than individual source rows. However, the question instead requires Apply the date condition in SQL WHERE before GROUP BY. because wHERE filters source rows prior to aggregation.

This action is appropriate when a model requires the latest shipment per order without relying on arbitrary first-row selection. Window ranking identifies a stable preferred row in each business group. However, the question instead requires Use a SQL window SUM partitioned by customer and ordered by transaction time. because window aggregation preserves detail rows while calculating cumulative results.

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 a SQL window SUM partitioned by customer and ordered by transaction time. because window aggregation preserves detail rows while calculating cumulative results.

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 a SQL window SUM partitioned by customer and ordered by transaction time. because window aggregation preserves detail rows while calculating cumulative results.

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 Use KQL `where` conditions on timestamp, service and severity. because kQL predicates narrow event records before analysis.

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 Use KQL `where` conditions on timestamp, service and severity. because kQL predicates narrow event records before analysis.

This action is appropriate when an incident analyst wants only timestamp, host and message columns from a verbose telemetry table. Projection reduces irrelevant columns and improves output readability. However, the question instead requires Use KQL `where` conditions on timestamp, service and severity. because kQL predicates narrow event records before analysis.

This action is appropriate when an operations team needs an average temperature for each device over one-hour intervals. Combining time bins and device groups yields meaningful time-series summaries. However, the question instead requires Use KQL `summarize count()` with `bin(timestamp, 5m)` and facility. because binning creates fixed temporal groups for event aggregates.

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 Use KQL `summarize count()` with `bin(timestamp, 5m)` and facility. because binning creates fixed temporal groups for event aggregates.

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 Use KQL `summarize count()` with `bin(timestamp, 5m)` and facility. because binning creates fixed temporal groups for event aggregates.

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 Define a DAX measure using SUM over the modeled revenue column. because measures evaluate in filter context and aggregate business facts at query time.

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 Define a DAX measure using SUM over the modeled revenue column. because measures evaluate in filter context and aggregate business facts at query time.

This action is appropriate when a business KPI needs revenue for one approved sales channel regardless of the chart's other channel values. CALCULATE modifies evaluation context to constrain the measure. However, the question instead requires Define a DAX measure using SUM over the modeled revenue column. because measures evaluate in filter context and aggregate business facts at query time.

This action is appropriate when a DAX measure returns identical sales across every dimension row despite valid relationships. Incorrect context or relationship direction can prevent row-level dimensional filters. However, the question instead requires Use a measure for slicer-responsive calculations instead of a static calculated column. because calculated columns store values at processing time while measures recalculate per query context.

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 Use a measure for slicer-responsive calculations instead of a static calculated column. because calculated columns store values at processing time while measures recalculate per query context.

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 Use a measure for slicer-responsive calculations instead of a static calculated column. because calculated columns store values at processing time while measures recalculate per query context.

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 the supported T-SQL environment for warehouse relational querying. because t-SQL matches SQL warehouse object and relational operations.

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 the supported T-SQL environment for warehouse relational querying. because t-SQL matches SQL warehouse object and relational operations.

This action is appropriate when an incident team needs subsecond exploratory filtering over timestamped Eventhouse telemetry. KQL is optimized for event-stream and time-series analysis patterns. However, the question instead requires Choose the supported T-SQL environment for warehouse relational querying. because t-SQL matches SQL warehouse object and relational operations.