Microsoft DP-800 Exam Dumps

The correct query is Option D because it starts from the input person and uses exactly two directed Knows edges in a single MATCH pattern:

MATCH(p1-(k1)->p2-(k2)->p3)

Microsoft documents that SQL Graph uses the MATCH predicate in the WHERE clause to express graph traversal patterns over node and edge tables, and directed relationships are written with arrow syntax such as node1-(edge)->node2.

Why D is correct:

It anchors the starting node with p1.PersonId = @StartPersonId.

It traverses two directed hops: p1 -> p2 -> p3.

It returns p3.PersonId, p3.DisplayName, which are the people reachable in exactly two Knows relationships.

Why the others are wrong:

A filters on DisplayName = DisplayName, which is unrelated to the required input parameter and does not correctly anchor the start node.

B reverses the traversal direction in the pattern.

C uses two separate MATCH predicates instead of the required single two-hop directed pattern. The proper graph pattern syntax supports chaining the hops directly in one MATCH expression.

For NationalIDNumber, you should use Deterministic encryption because the stored procedure performs point lookups using this column. Deterministic encryption allows equality comparisons and indexing, which are essential for the WHERE clause lookup operations. For InvestigationNotes, you should use Randomized encryption because the procedure only returns this column without filtering on it. Since there are no equality comparisons or index operations on InvestigationNotes, randomized encryption provides the highest security level by producing different ciphertexts for the same plaintext value, while still allowing the column to be retrieved and displayed.

According to GitHub Copilot instruction precedence rules, the hierarchy from highest to lowest precedence is: personal instructions, agent-specific instructions, repository-wide instructions, and organization-wide instructions. Therefore, agent-specific instructions take the highest precedence among all levels. Personal instructions would only apply if they exist for the individual user, but in the context of comparing the different scope levels mentioned (organization, repository, agent, and personal), agent-specific instructions have the highest precedence in the evaluation chain.

The correct answer is the first option. For a 2M item dataset where performance must meet a 2-second SLA, Approximate Nearest Neighbor (ANN) indexing with HNSW is the appropriate choice. ANN trades minor accuracy loss for significant speed improvements, typically achieving sub-second queries on large datasets. VECTOR_NORMALIZE is a best practice to ensure consistent distance calculations. The second option confuses traditional indexing with vector indexing—nonclustered indexes do not provide the speed needed for vector search. ENN (third option) guarantees exact results but provides no speed improvement over a full scan, making it unsuitable for this scale. Partitioning (fourth option) does not solve the fundamental performance problem and adds operational complexity. While hybrid search (fifth option) can be valuable in some scenarios, it typically adds latency rather than reducing it, and the question specifically requires meeting the performance SLA.

The correct answer is C because the email must be normalized by removing only the subaddressing portion between the plus sign and the @, while preserving the domain. JSON_VALUE is the correct function to extract the scalar email value from the JSON document. Microsoft states that JSON_VALUE is used to extract a scalar value from JSON text.

Then REGEXP_REPLACE should remove the pattern \+.*@ and replace it with a single @. For example:

user1+promo@contoso.com user1@contoso.com

Microsoft documents that REGEXP_REPLACE returns the source string with text matching the regular expression replaced by the replacement string, and that an empty or custom replacement string can be used to reshape the result.

Why the other options are wrong:

A removes everything from + to the end of the string, which would leave user1 and lose @contoso.com.

B tries to extract a string that already excludes +..., but it does not reliably reconstruct the normalized address in this pattern.

D also removes everything after +, including the domain, which is incorrect.

So the normalized-email expression is:

REGEXP_REPLACE(JSON_VALUE(Payload, '$.customer_email'), '\+.*@', '@')