Exam Bundle

The affected query returns to the approved runtime profile and a forced-plan health check detects no unsupported plan behavior. That result is evidence for another corrective change: Use Query Store performance evidence and a supported plan forcing or regression correction after validating applicability. The alternative problem is: A monitoring team assumes all slow requests come from missing indexes but Query Store identifies a sudden plan regression without a schema change. The current Brookside Manufacturing issue is instead: Azure SQL Intelligent Insights reports degraded database performance but administrators ignore its diagnostic context and scale every database equally. Its decisive acceptance evidence would be: The diagnosed metric and affected query recover in a follow-up observation while unrelated databases retain their original sizing.

The rewritten query returns identical rows while the execution plan reads the targeted date range efficiently. That result is evidence for another corrective change: Rewrite the date condition into a search-argument-friendly range predicate and confirm its semantic correctness. The alternative problem is: A query performs a string function on an indexed date column in the WHERE predicate and loses partition or index seek efficiency. The current Brookside Manufacturing issue is instead: Azure SQL Intelligent Insights reports degraded database performance but administrators ignore its diagnostic context and scale every database equally. Its decisive acceptance evidence would be: The diagnosed metric and affected query recover in a follow-up observation while unrelated databases retain their original sizing.

The targeted query uses an effective seek or narrower scan with fewer logical reads and acceptable write overhead. That result is evidence for another corrective change: Evaluate an appropriate nonclustered index using predicates, selectivity and maintenance costs, then test the actual execution plan. The alternative problem is: A reporting query scans a very large transaction table for a selective customer ID because the table lacks a useful access path. The current Brookside Manufacturing issue is instead: Azure SQL Intelligent Insights reports degraded database performance but administrators ignore its diagnostic context and scale every database equally. Its decisive acceptance evidence would be: The diagnosed metric and affected query recover in a follow-up observation while unrelated databases retain their original sizing.

Rewrite the query to project only required columns and review supporting indexes for the access pattern. That relates to a separate SQL administration problem: A SQL report selects all columns from a wide transactional table even though it needs only three, causing high memory and network usage. The Granite SaaS requirement is instead: Azure SQL Intelligent Insights reports degraded database performance but administrators ignore its diagnostic context and scale every database equally. That approach does not directly establish the required fix; the requested acceptance evidence is: The diagnosed metric and affected query recover in a follow-up observation while unrelated databases retain their original sizing.

Enable and configure Query Store with appropriate capture and retention policies before diagnosing plan performance regressions. That relates to a separate SQL administration problem: A frequently executed Azure SQL query regresses after an application update but Query Store is disabled, leaving no historical plan comparison. The Granite SaaS requirement is instead: Azure SQL Intelligent Insights reports degraded database performance but administrators ignore its diagnostic context and scale every database equally. That approach does not directly establish the required fix; the requested acceptance evidence is: The diagnosed metric and affected query recover in a follow-up observation while unrelated databases retain their original sizing.

Inspect active requests, session wait information and blocking chains using supported DMVs or Extended Events. That relates to a separate SQL administration problem: Two SQL sessions are blocked for minutes and the incident handler kills random connections without identifying the lead blocking transaction. The Granite SaaS requirement is instead: Azure SQL Intelligent Insights reports degraded database performance but administrators ignore its diagnostic context and scale every database equally. That approach does not directly establish the required fix; the requested acceptance evidence is: The diagnosed metric and affected query recover in a follow-up observation while unrelated databases retain their original sizing.

The tuned query completes with fewer spill events and lower tempdb I/O for representative datasets. That result is evidence for another corrective change: Inspect actual execution plan memory grants, spill warnings and relevant DMVs before selecting an indexing or query change. The alternative problem is: A SQL optimizer chooses an expensive sort and spill during a high-volume query but support only monitors aggregate CPU. The current Granite SaaS issue is instead: Azure SQL Intelligent Insights reports degraded database performance but administrators ignore its diagnostic context and scale every database equally. Its decisive acceptance evidence would be: The diagnosed metric and affected query recover in a follow-up observation while unrelated databases retain their original sizing.

The same query has historical plan and runtime records that identify the regressed plan and its performance difference. That result is evidence for another corrective change: Enable and configure Query Store with appropriate capture and retention policies before diagnosing plan performance regressions. The alternative problem is: A frequently executed Azure SQL query regresses after an application update but Query Store is disabled, leaving no historical plan comparison. The current Granite SaaS issue is instead: Azure SQL Intelligent Insights reports degraded database performance but administrators ignore its diagnostic context and scale every database equally. Its decisive acceptance evidence would be: The diagnosed metric and affected query recover in a follow-up observation while unrelated databases retain their original sizing.

After the targeted I/O or query change physical reads and latency improve while CPU alone is not used as proof. That result is evidence for another corrective change: Correlate wait types with execution plans, physical reads and storage latency to locate the actual I/O bottleneck. The alternative problem is: A query waits on PAGEIOLATCH-related events but the DBA assumes it is always a CPU bottleneck and increases cores. The current Granite SaaS issue is instead: Azure SQL Intelligent Insights reports degraded database performance but administrators ignore its diagnostic context and scale every database equally. Its decisive acceptance evidence would be: The diagnosed metric and affected query recover in a follow-up observation while unrelated databases retain their original sizing.

Compare estimated and actual plans with row counts and resource metrics to identify estimation or join-selection problems. That relates to a separate SQL administration problem: A SQL DBA sees an estimated execution plan only and concludes a query cannot have cardinality estimation errors at runtime. The Granite SaaS requirement is instead: A data import starts running slowly as an application joins multiple large tables without selective predicates and the team only adds hardware. That approach does not directly establish the required fix; the requested acceptance evidence is: The optimized import returns the required dataset with reduced logical reads and a measured improvement under controlled load.

Collect SQL deadlock reports through supported monitoring and identify competing resource acquisition orders before fixing transaction logic. That relates to a separate SQL administration problem: A high-concurrency app hits deadlocks but operations treats them as ordinary slow queries and fails to capture the deadlock graph. The Granite SaaS requirement is instead: A data import starts running slowly as an application joins multiple large tables without selective predicates and the team only adds hardware. That approach does not directly establish the required fix; the requested acceptance evidence is: The optimized import returns the required dataset with reduced logical reads and a measured improvement under controlled load.

Rewrite the date condition into a search-argument-friendly range predicate and confirm its semantic correctness. That relates to a separate SQL administration problem: A query performs a string function on an indexed date column in the WHERE predicate and loses partition or index seek efficiency. The Granite SaaS requirement is instead: A data import starts running slowly as an application joins multiple large tables without selective predicates and the team only adds hardware. That approach does not directly establish the required fix; the requested acceptance evidence is: The optimized import returns the required dataset with reduced logical reads and a measured improvement under controlled load.

The targeted query uses an effective seek or narrower scan with fewer logical reads and acceptable write overhead. That result is evidence for another corrective change: Evaluate an appropriate nonclustered index using predicates, selectivity and maintenance costs, then test the actual execution plan. The alternative problem is: A reporting query scans a very large transaction table for a selective customer ID because the table lacks a useful access path. The current Granite SaaS issue is instead: A data import starts running slowly as an application joins multiple large tables without selective predicates and the team only adds hardware. Its decisive acceptance evidence would be: The optimized import returns the required dataset with reduced logical reads and a measured improvement under controlled load.

The actual plan demonstrates corrected cardinality and reduced work for the representative parameter set. That result is evidence for another corrective change: Compare estimated and actual plans with row counts and resource metrics to identify estimation or join-selection problems. The alternative problem is: A SQL DBA sees an estimated execution plan only and concludes a query cannot have cardinality estimation errors at runtime. The current Granite SaaS issue is instead: A data import starts running slowly as an application joins multiple large tables without selective predicates and the team only adds hardware. Its decisive acceptance evidence would be: The optimized import returns the required dataset with reduced logical reads and a measured improvement under controlled load.

After the targeted I/O or query change physical reads and latency improve while CPU alone is not used as proof. That result is evidence for another corrective change: Correlate wait types with execution plans, physical reads and storage latency to locate the actual I/O bottleneck. The alternative problem is: A query waits on PAGEIOLATCH-related events but the DBA assumes it is always a CPU bottleneck and increases cores. The current Granite SaaS issue is instead: A data import starts running slowly as an application joins multiple large tables without selective predicates and the team only adds hardware. Its decisive acceptance evidence would be: The optimized import returns the required dataset with reduced logical reads and a measured improvement under controlled load.

Compare Query Store plans and runtime statistics to isolate parameter sensitivity and consider a supported plan or query correction. That relates to a separate SQL administration problem: A stored procedure occasionally chooses an inefficient execution plan after parameter changes and the team blindly rebuilds every table index. The Lakeside Research requirement is instead: A data import starts running slowly as an application joins multiple large tables without selective predicates and the team only adds hardware. That approach does not directly establish the required fix; the requested acceptance evidence is: The optimized import returns the required dataset with reduced logical reads and a measured improvement under controlled load.

Correlate wait types with execution plans, physical reads and storage latency to locate the actual I/O bottleneck. That relates to a separate SQL administration problem: A query waits on PAGEIOLATCH-related events but the DBA assumes it is always a CPU bottleneck and increases cores. The Lakeside Research requirement is instead: A data import starts running slowly as an application joins multiple large tables without selective predicates and the team only adds hardware. That approach does not directly establish the required fix; the requested acceptance evidence is: The optimized import returns the required dataset with reduced logical reads and a measured improvement under controlled load.

Review the reported root-cause context and correlate it with Query Store and platform telemetry before implementing a targeted fix. That relates to a separate SQL administration problem: Azure SQL Intelligent Insights reports degraded database performance but administrators ignore its diagnostic context and scale every database equally. The Lakeside Research requirement is instead: A data import starts running slowly as an application joins multiple large tables without selective predicates and the team only adds hardware. That approach does not directly establish the required fix; the requested acceptance evidence is: The optimized import returns the required dataset with reduced logical reads and a measured improvement under controlled load.

The targeted query uses an effective seek or narrower scan with fewer logical reads and acceptable write overhead. That result is evidence for another corrective change: Evaluate an appropriate nonclustered index using predicates, selectivity and maintenance costs, then test the actual execution plan. The alternative problem is: A reporting query scans a very large transaction table for a selective customer ID because the table lacks a useful access path. The current Lakeside Research issue is instead: A data import starts running slowly as an application joins multiple large tables without selective predicates and the team only adds hardware. Its decisive acceptance evidence would be: The optimized import returns the required dataset with reduced logical reads and a measured improvement under controlled load.

The identified lead blocker is corrected and the blocked sessions complete while unrelated transactions are left running. That result is evidence for another corrective change: Inspect active requests, session wait information and blocking chains using supported DMVs or Extended Events. The alternative problem is: Two SQL sessions are blocked for minutes and the incident handler kills random connections without identifying the lead blocking transaction. The current Lakeside Research issue is instead: A data import starts running slowly as an application joins multiple large tables without selective predicates and the team only adds hardware. Its decisive acceptance evidence would be: The optimized import returns the required dataset with reduced logical reads and a measured improvement under controlled load.

Under concurrent load the lead transaction holds locks for less time and dependent requests no longer show sustained blocking. That result is evidence for another corrective change: Shorten the transaction and move the external call outside the critical lock-holding region where consistency rules permit. The alternative problem is: A transaction holds locks while calling an external service and unrelated queries queue behind its long-lived lock scope. The current Lakeside Research issue is instead: A data import starts running slowly as an application joins multiple large tables without selective predicates and the team only adds hardware. Its decisive acceptance evidence would be: The optimized import returns the required dataset with reduced logical reads and a measured improvement under controlled load.

Enable and configure Query Store with appropriate capture and retention policies before diagnosing plan performance regressions. That relates to a separate SQL administration problem: A frequently executed Azure SQL query regresses after an application update but Query Store is disabled, leaving no historical plan comparison. The Lakeside Research requirement is instead: A high-concurrency app hits deadlocks but operations treats them as ordinary slow queries and fails to capture the deadlock graph. That approach does not directly establish the required fix; the requested acceptance evidence is: A concurrency replay no longer produces the original deadlock cycle and the app handles any remaining retries predictably.

Correlate wait types with execution plans, physical reads and storage latency to locate the actual I/O bottleneck. That relates to a separate SQL administration problem: A query waits on PAGEIOLATCH-related events but the DBA assumes it is always a CPU bottleneck and increases cores. The Lakeside Research requirement is instead: A high-concurrency app hits deadlocks but operations treats them as ordinary slow queries and fails to capture the deadlock graph. That approach does not directly establish the required fix; the requested acceptance evidence is: A concurrency replay no longer produces the original deadlock cycle and the app handles any remaining retries predictably.

Compare estimated and actual plans with row counts and resource metrics to identify estimation or join-selection problems. That relates to a separate SQL administration problem: A SQL DBA sees an estimated execution plan only and concludes a query cannot have cardinality estimation errors at runtime. The Lakeside Research requirement is instead: A high-concurrency app hits deadlocks but operations treats them as ordinary slow queries and fails to capture the deadlock graph. That approach does not directly establish the required fix; the requested acceptance evidence is: A concurrency replay no longer produces the original deadlock cycle and the app handles any remaining retries predictably.

After the targeted I/O or query change physical reads and latency improve while CPU alone is not used as proof. That result is evidence for another corrective change: Correlate wait types with execution plans, physical reads and storage latency to locate the actual I/O bottleneck. The alternative problem is: A query waits on PAGEIOLATCH-related events but the DBA assumes it is always a CPU bottleneck and increases cores. The current Lakeside Research issue is instead: A high-concurrency app hits deadlocks but operations treats them as ordinary slow queries and fails to capture the deadlock graph. Its decisive acceptance evidence would be: A concurrency replay no longer produces the original deadlock cycle and the app handles any remaining retries predictably.

The diagnosed metric and affected query recover in a follow-up observation while unrelated databases retain their original sizing. That result is evidence for another corrective change: Review the reported root-cause context and correlate it with Query Store and platform telemetry before implementing a targeted fix. The alternative problem is: Azure SQL Intelligent Insights reports degraded database performance but administrators ignore its diagnostic context and scale every database equally. The current Lakeside Research issue is instead: A high-concurrency app hits deadlocks but operations treats them as ordinary slow queries and fails to capture the deadlock graph. Its decisive acceptance evidence would be: A concurrency replay no longer produces the original deadlock cycle and the app handles any remaining retries predictably.

Under concurrent load the lead transaction holds locks for less time and dependent requests no longer show sustained blocking. That result is evidence for another corrective change: Shorten the transaction and move the external call outside the critical lock-holding region where consistency rules permit. The alternative problem is: A transaction holds locks while calling an external service and unrelated queries queue behind its long-lived lock scope. The current Lakeside Research issue is instead: A high-concurrency app hits deadlocks but operations treats them as ordinary slow queries and fails to capture the deadlock graph. Its decisive acceptance evidence would be: A concurrency replay no longer produces the original deadlock cycle and the app handles any remaining retries predictably.

Correlate wait types with execution plans, physical reads and storage latency to locate the actual I/O bottleneck. That relates to a separate SQL administration problem: A query waits on PAGEIOLATCH-related events but the DBA assumes it is always a CPU bottleneck and increases cores. The Westhaven Retail requirement is instead: A high-concurrency app hits deadlocks but operations treats them as ordinary slow queries and fails to capture the deadlock graph. That approach does not directly establish the required fix; the requested acceptance evidence is: A concurrency replay no longer produces the original deadlock cycle and the app handles any remaining retries predictably.

Shorten the transaction and move the external call outside the critical lock-holding region where consistency rules permit. That relates to a separate SQL administration problem: A transaction holds locks while calling an external service and unrelated queries queue behind its long-lived lock scope. The Westhaven Retail requirement is instead: A high-concurrency app hits deadlocks but operations treats them as ordinary slow queries and fails to capture the deadlock graph. That approach does not directly establish the required fix; the requested acceptance evidence is: A concurrency replay no longer produces the original deadlock cycle and the app handles any remaining retries predictably.

Enable and configure Query Store with appropriate capture and retention policies before diagnosing plan performance regressions. That relates to a separate SQL administration problem: A frequently executed Azure SQL query regresses after an application update but Query Store is disabled, leaving no historical plan comparison. The Westhaven Retail requirement is instead: A high-concurrency app hits deadlocks but operations treats them as ordinary slow queries and fails to capture the deadlock graph. That approach does not directly establish the required fix; the requested acceptance evidence is: A concurrency replay no longer produces the original deadlock cycle and the app handles any remaining retries predictably.

The identified lead blocker is corrected and the blocked sessions complete while unrelated transactions are left running. That result is evidence for another corrective change: Inspect active requests, session wait information and blocking chains using supported DMVs or Extended Events. The alternative problem is: Two SQL sessions are blocked for minutes and the incident handler kills random connections without identifying the lead blocking transaction. The current Westhaven Retail issue is instead: A high-concurrency app hits deadlocks but operations treats them as ordinary slow queries and fails to capture the deadlock graph. Its decisive acceptance evidence would be: A concurrency replay no longer produces the original deadlock cycle and the app handles any remaining retries predictably.

The affected query returns to the approved runtime profile and a forced-plan health check detects no unsupported plan behavior. That result is evidence for another corrective change: Use Query Store performance evidence and a supported plan forcing or regression correction after validating applicability. The alternative problem is: A monitoring team assumes all slow requests come from missing indexes but Query Store identifies a sudden plan regression without a schema change. The current Westhaven Retail issue is instead: A high-concurrency app hits deadlocks but operations treats them as ordinary slow queries and fails to capture the deadlock graph. Its decisive acceptance evidence would be: A concurrency replay no longer produces the original deadlock cycle and the app handles any remaining retries predictably.

The diagnosed metric and affected query recover in a follow-up observation while unrelated databases retain their original sizing. That result is evidence for another corrective change: Review the reported root-cause context and correlate it with Query Store and platform telemetry before implementing a targeted fix. The alternative problem is: Azure SQL Intelligent Insights reports degraded database performance but administrators ignore its diagnostic context and scale every database equally. The current Westhaven Retail issue is instead: A high-concurrency app hits deadlocks but operations treats them as ordinary slow queries and fails to capture the deadlock graph. Its decisive acceptance evidence would be: A concurrency replay no longer produces the original deadlock cycle and the app handles any remaining retries predictably.