Microsoft DP-800 - Developing AI-Enabled Database Solutions

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 ' ), ' \+.*@ ' , ' @ ' )

The correct insertion at line 22 is FOR JSON PATH, WITHOUT_ARRAY_WRAPPER .

The request body for the Azure OpenAI chat completions call must be a single JSON object containing the messages array with both the system/user content and the retrieved chunks. Microsoft documents that FOR JSON PATH is the preferred way to shape JSON output, especially when you want precise control over nested property names like messages[0].role and messages[1] .content.

The key detail is WITHOUT_ARRAY_WRAPPER . By default, FOR JSON returns results enclosed in square brackets as a JSON array. Microsoft documents that WITHOUT_ARRAY_WRAPPER removes those brackets so a single JSON object is produced instead. That is exactly what is needed here for @payload, because the stored procedure is building one request body, not an array of request bodies.

This does not meet the goal. A row-by-row DELETE against the oldest month is not the lowest-impact way to purge data from a monthly partitioned table. Microsoft’s partitioning guidance specifically says partitioning lets you perform maintenance and retention operations more efficiently by targeting just the relevant partition, including the ability to truncate data in a single partition .

The proposed statement:

DELETE FROM dbo.Orders

WHERE OrderDate < DATEADD(month, -36, SYSUTCDATETIME());

would log row deletions and can hold locks longer, creating more overhead for other queries than a partition-level maintenance operation. Since the table is already partitioned by month , the expected low-impact approach is to operate on the oldest partition directly, not issue a broad delete predicate over rows. Microsoft explicitly highlights partition-targeted truncation as a faster, more efficient retention operation than working against the whole table or rowset.

Verified Answer : =

Support agents must see only the rows of their own TenantId → Create a row-level security (RLS) predicate that uses the user context.

Support agents must see only the domain name portion of CustomerEmail → Configure dynamic data masking on selected columns.

Comprehensive and Detailed Explanation with all Developing AI-Enabled Database Solutions documents : =

For the TenantId requirement, use Row-Level Security (RLS) . RLS is designed to restrict which rows a database principal can access. A security predicate can compare the row ' s TenantId with tenant information derived from the current user ' s session or security context, so support agents querying the same Tickets table see only rows belonging to their own tenant. This is the correct multitenant isolation mechanism because it is enforced by the database rather than relying on individual reporting tools or application-side filtering.

For CustomerEmail , use Dynamic Data Masking (DDM) . DDM controls how sensitive column values are displayed to users who do not have UNMASK permission. A partial masking rule can conceal the local/user- specific portion of an email address while exposing only the required portion, such as its domain, according to the masking configuration.

The remaining choices do not satisfy these specific requirements. Transparent Data Encryption (TDE) protects database files at rest but does not filter rows or selectively obscure query results. Always Encrypted protects sensitive values cryptographically and is appropriate when the database engine itself should not see plaintext, but it is not the right mechanism when support agents must deliberately see a controlled portion of an email address.

Final drag-and-drop selections:

Own TenantId rows → Create a row-level security (RLS) predicate that uses the user context

Only domain portion of CustomerEmail → Configure dynamic data masking on selected columns

Verified Answer : =

Vector index column → embedding

Vector search function → VECTOR_SEARCH

Final clause → ORDER BY s.distance

The first selection is embedding because CREATE VECTOR INDEX must target the column that stores vector data. Microsoft documents the syntax as CREATE VECTOR INDEX ... ON object (vector_column) , so the index belongs on dbo.Products.embedding , not on distance or product_name .

The second selection is VECTOR_SEARCH . This function is designed for vector similarity retrieval and works with vector indexes in SQL database in Microsoft Fabric . In the shown code, the supplied @query_vector VECTOR(1536) is compared against the embedding column using cosine distance, and TOP_N = 10 requests the ten nearest matches. Microsoft specifically documents VECTOR_SEARCH for approximate nearest-neighbor searches and its integration with vector indexes.

The final clause is ORDER BY s.distance because VECTOR_SEARCH returns a distance value representing how far each stored vector is from the supplied query vector. With cosine distance, smaller distance means greater similarity , so ascending order returns the most relevant products first.

Therefore, the completed selections are:

CREATE VECTOR INDEX idx_products_embedding

ON dbo.Products (embedding)

WITH (METRIC = ' cosine ' , TYPE = ' DiskANN ' );

FROM VECTOR_SEARCH (

TABLE = dbo.Products AS t,

COLUMN = embedding,

SIMILAR_TO = @query_vector,

METRIC = ' cosine ' ,

TOP_N = 10

) AS s

ORDER BY s.distance;

So the verified hotspot answers are embedding → VECTOR_SEARCH → ORDER BY s.distance .

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.

The requirement is to ensure embeddings are updated every time the underlying content changes without relying on a nightly batch job. The right design is to enable change tracking on the source table so an external process can identify which rows changed and regenerate embeddings only for those rows. Microsoft documents that change detection mechanisms are used to pick up new and updated rows incrementally , which is the right pattern when you need near-continuous refresh instead of full nightly rebuilds.

This is better than:

A. fixed-size chunking , which affects chunk strategy but not change detection.

B. a smaller embedding model , which affects model cost/latency but not update triggering.

C. table triggers , which would push embedding-maintenance logic directly into write operations and is generally not the best design for AI-processing pipelines. The question specifically asks for a solution that replaces the nightly batch requirement, not one that performs heavyweight work inline during every transaction.