DP-800 Exam Dumps - Microsoft Certified: SQL AI Developer Questions and Answers

The first statement is No . The requirement says telemetry data must be stored in a partitioned table to provide predictable performance for ingestion and retention operations. However, the shown CREATE TABLE statement does not define a partition function or partition scheme, and the table is created with a regular clustered primary key on TelemetryId. Microsoft’s partitioning guidance states that creating a partitioned table requires a partition function , a partition scheme , and creating the table or index on that partition scheme using a partitioning column. None of that appears in the code, so the table is not partitioned.

The second statement is Yes . The code creates a JSON index named JI_VehicleTelemetry_Location on LocationJson for these specific JSON paths: $.location.latitude, $.location.longitude, and $.location.accuracy. That matches the requirement that those JSON properties must be filterable by using an index seek . Microsoft documents that JSON indexing is used to optimize filtering and sorting on JSON properties, and the index only helps for the properties included in the index definition.

The third statement is No . The JSON index is defined only for latitude, longitude, and accuracy. A query filtering on $.location.heading references a different path that is not included in the index definition, so that query would not use JI_VehicleTelemetry_Location for that predicate. JSON indexes are path-specific; they do not automatically cover unrelated properties in the same JSON document.

The correct answer is C because the current query uses VECTOR_DISTANCE( ' cosine ' , @query_vector, embedding) , which performs an exact vector distance calculation . Microsoft explicitly documents that VECTOR_DISTANCE does not use a vector index , even when one exists. Exact k-nearest-neighbor searches can require scanning large numbers of vectors and calculating distances row by row, which explains the observed CPU spikes and increased semantic-search latency during peak load.

A vector index on products.embedding is specifically designed to accelerate nearest-neighbor search, and VECTOR_SEARCH is the Transact-SQL function that can use that approximate nearest-neighbor index when the index metric matches the query metric. Using METRIC = ' cosine ' preserves the same similarity metric currently used by App1 while reducing the amount of computation required.

The other choices are incorrect:

A normalizes vectors but does not replace the expensive exact search with indexed ANN retrieval.

B replaces semantic vector search with lexical full-text search and changes the feature’s behavior.

D a standard nonclustered B-tree index cannot accelerate vector-distance operations.

E converting embeddings to VARBINARY(8000) removes native vector semantics and does not solve the performance problem.

Therefore, the exam-aligned solution is create a vector index and use VECTOR_SEARCH with cosine distance .

For authentication , the correct choice is Enable a managed identity and use Microsoft Entra authentication . Azure App Service supports managed identity, and Microsoft documents this as the recommended way to connect to Azure SQL Database without passwords or secrets . This minimizes administrative effort because there are no SQL passwords to rotate, store, or manage.

For network access , the correct choice is Create a private endpoint and disable public network access . Microsoft documents that when public network access is disabled , Azure SQL Database only accepts connections through private endpoints . That keeps the database traffic on Azure private networking rather than exposing it through the public endpoint. Microsoft also notes that simply adding a private endpoint does not disable public access by itself, so disabling public network access is part of the correct configuration.

The other options are weaker:

Rotated SQL credentials or storing SQL logins in Key Vault still use passwords and create more admin overhead.

Allowing Azure services, adding outbound IP firewall rules, or database firewall rules still rely on the public endpoint , so they do not best satisfy the requirement that database traffic remain within the subscription.

Verified Answer : =

queryType → " semantic "

semanticConfiguration → " hotels "

captions → " extractive "

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

The correct configuration is queryType: " semantic " , semanticConfiguration: " hotels " , and captions: " extractive " .

The request is already a hybrid search because it contains both a textual search value ( " ocean view " ) and a vectorQueries block targeting DescriptionVector . Microsoft documents that hybrid search executes full-text and vector searches together and merges their result sets. When semantic ranking is required, queryType must be set to " semantic " .

The semanticConfiguration value must reference the semantic configuration defined for the target index. Since the index in this question is named hotels and the available answer choice is " hotels " , that is the appropriate configuration value in the supplied answer set. Microsoft’s REST examples show that semantic queries require both queryType: " semantic " and a valid semanticConfiguration .

To return semantic captions, use " captions " : " extractive " . Microsoft states that extractive captions identify the most relevant passages from the indexed content and return them with each result. They are generated from existing document text rather than generated by an LLM.

The completed request body is therefore:

{

" search " : " ocean view " ,

" queryType " : " semantic " ,

" semanticConfiguration " : " hotels " ,

" captions " : " extractive " ,

" top " : 10,

" hybridSearch " : {

" maxTextRecallSize " : 50

},

" vectorQueries " : [

{

" kind " : " vector " ,

" vector " : [ /* embedding array */ ],

" fields " : " DescriptionVector " ,

" k " : 50

}

]

}

Final drag-and-drop selections:

First target: " semantic "

Second target: " hotels "

Third target: " extractive "

The first statement is Yes . Embeddings are used to represent the semantic meaning of content, and vector search is for conceptually similar matches over that content. Here, the semantically meaningful fields are product_name, category, and description. Using those together supports natural-language search, while brand and price can be handled as structured filters outside the embedding itself. This is an inference from Microsoft’s guidance that vector search works over embeddings representing content meaning, while filters remain part of the nonvector query pipeline.

The second statement is No . price changes multiple times per day and is a structured numeric attribute, not stable semantic content. Since the requirement already says customers can apply structured filters for brand and price , price does not need to be embedded into the text. Embedding volatile numeric values would also make embeddings stale faster without improving the semantic-search objective. This is again an inference grounded in Microsoft’s distinction between vector similarity over content and filtering/sorting over nonvector fields.

The third statement is Yes . In SQL Server’s vector type, the default underlying base type is float32 unless float16 is specified explicitly.

The members of SqlUsers can modify the data in SalesDB via SalesApi. → No

The members of SqlUsers can view the data in SalesDB via SalesApi. → No

The members of SqlUsers can change the field mappings of SalesApi. → Yes

For both viewing and modifying data through SalesApi, the key missing permission is Run Queries and Mutations . Microsoft’s Fabric GraphQL documentation states that callers need Execute permissions for the GraphQL API , which correspond to the Run Queries and Mutations option, and with SSO connectivity they also need appropriate permissions on the underlying data source. In the exhibit, SqlUsers has View and Edit GraphQL item selected, but Run Queries and Mutations is not selected, so members cannot query or mutate data through the API.

The third statement is Yes because the group was explicitly granted View and Edit GraphQL item . That permission is the one that allows users to open and modify the GraphQL item itself, including schema-related configuration such as field mappings in the API item. The workspace Viewer role does not by itself grant query execution through the API, but the direct GraphQL item permission shown does allow editing the item.

The correct drag-and-drop mapping is based on the documented behavior of the new SQL regular expression functions.

For RawNumber , the requirement is to return the first substring in MessageRaw that matches the phone-number pattern, or NULL if nothing matches. That is exactly what REGEXP_SUBSTR does: it extracts the matched substring from the source text. Microsoft documents REGEXP_SUBSTR as the function that “extracts parts of a string based on a regular expression pattern” and returns the matched occurrence.

For DigitsOnly , you first need the matched phone substring, then remove all non-digit characters from it. The correct combined expression is REGEXP_REPLACE( REGEXP_SUBSTR( so the matched substring is passed into REGEXP_REPLACE, which strips characters matching \D. Microsoft documents REGEXP_REPLACE as returning a modified source string with matching patterns replaced. Using it around REGEXP_SUBSTR satisfies the “digits only or NULL” requirement in one select expression.

For PhoneStatus , the requirement is simply to return Valid when a phone number exists and Missing otherwise. That is a Boolean test, so REGEXP_LIKE is the right function. Microsoft documents REGEXP_LIKE as returning a Boolean value indicating whether the input matches the regex pattern.

For the vector portion, the correct choice is VECTOR_DISTANCE and order by distance ascending . The requirement is to build a combined weighted formula using the actual vector distance. Microsoft documents that VECTOR_DISTANCE returns the exact distance between two vectors. Since lower distance means greater similarity, ascending distance is the right direction for ranking. VECTOR_SEARCH is for ANN retrieval, but this hotspot specifically asks for a weighted formula based on distance , so VECTOR_DISTANCE is the appropriate operator.

For the keyword portion, the correct choice is CONTAINSTABLE on description and return ranked matches . Microsoft documents that CONTAINSTABLE returns a RANK column from 0 through 1000 , which is exactly what is needed for weighted scoring in a hybrid formula.

For the final ranking expression, the best choice is order by (distance * 0.6) + ((1.0 - RANK/1000.0) * 0.4) . This works because vector distance is a lower-is-better metric, while full-text RANK is a higher-is-better metric. Dividing RANK by 1000 normalizes it to the documented range, and subtracting from 1.0 converts it into a lower-is-better term so both components can be combined consistently in one ascending score. This final step is a sound inference based on Microsoft’s documented distance semantics and full-text rank range.

PhoneRaw extraction → JSON_VALUE(c.ProfileJson, ' $.contact.phone ' )

PhoneNumerals → REGEXP_REPLACE(p.PhoneRaw, ' [^0-9] ' , ' ' )

WHERE condition → p.PhoneRaw

The first correct selection is JSON_VALUE(c.ProfileJson, ' $.contact.phone ' ) because the phone number is stored as a scalar JSON property . Microsoft documents that JSON_VALUE extracts a scalar value from JSON text, whereas JSON_QUERY is intended for JSON objects or arrays.

The second selection is REGEXP_REPLACE(p.PhoneRaw, ' [^0-9] ' , ' ' ) . The regular expression [^0-9] matches every character that is not a digit . Replacing all such characters with an empty string converts a formatted value such as:

+000 000-000-0000

into:

0000000000000

Microsoft documents that REGEXP_REPLACE returns the source string after occurrences matching the regular expression are replaced, and it applies to Azure SQL Database.

The final blank is p.PhoneRaw , producing:

WHERE p.PhoneRaw IS NOT NULL;

This excludes customers that do not have a phone value while preserving one output row for each customer that does.

The completed query is:

WITH PhoneCTE AS

(

SELECT DISTINCT

c.CustomerId,

JSON_VALUE(c.ProfileJson, ' $.contact.phone ' ) AS PhoneRaw

FROM dbo.Customers AS c

)

SELECT

p.CustomerId,

REGEXP_REPLACE(p.PhoneRaw, ' [^0-9] ' , ' ' ) AS PhoneNumerals

FROM PhoneCTE AS p

WHERE p.PhoneRaw IS NOT NULL;

Final drag-and-drop selections:

First target: JSON_VALUE(c.ProfileJson, ' $.contact.phone ' )

Second target: REGEXP_REPLACE(p.PhoneRaw, ' [^0-9] ' , ' ' )

Third target: p.PhoneRaw

where exists 2. where p.PatientID = pr.PatientID Otherwise we filter PatientID twice. Having in the subquery does not work without group by and the date filter does not work without where.