Free DP-800 practice test: 30 questions with answers

Always Encrypted keeps data encrypted from the client to storage, and deterministic encryption allows equality comparisons. Dynamic Data Masking only obscures output, TDE protects files, and plain text with a view exposes the data.

Dynamic Data Masking obscures returned values for users without the unmask permission while leaving the stored data unchanged. Encryption, CHECK constraints, and row filtering solve different problems.

Row-Level Security applies a predicate function to filter rows for each user automatically, regardless of the query. Editable views, per-user databases, and client-side filters can be bypassed or do not scale.

Granting only SELECT on the specific object applies least privilege. db_owner and ALTER grant far more, and sharing an administrator login removes accountability.

Managed identities provide Azure AD-based authentication without stored credentials. Stored passwords, embedded keys, and shared administrator logins are insecure.

Auditing records access and changes to defined objects and sends the logs to a chosen destination for review. Masking hides values, constraints validate data, and sequences generate numbers.

Query Store tracks plan history and runtime statistics, and actual execution plans show where time is spent. Editors, spreadsheets, and printouts do not reveal execution behaviour.

A deadlock is a circular wait among transactions, which the engine resolves by terminating one. Replication lag and stale statistics are different issues, and backup failures do not involve locks.

Snapshot-based isolation uses row versioning so readers do not block writers and see consistent data. Serializable locking reduces concurrency, dirty reads return uncommitted data, and no isolation risks inconsistency.

Rebuilding or reorganizing fragmented indexes restores efficient page layout, with the choice depending on fragmentation. Dropping statistics, recreating tables hourly, and permanently disabling indexes all harm performance.

Columnstore indexes store data by column and compress it well, which speeds analytical aggregations over large tables. Per-column nonclustered indexes and unique IDs do not serve large aggregations, and scans without indexes are slow.

System-versioned temporal tables keep history automatically in a history table and support point-in-time queries with FOR SYSTEM_TIME. A heap, a plain view, or a table variable does not preserve the history automatically.

A JSON column holds variable attributes, and indexing computed columns over the values queried often makes lookups fast. Unstructured text, very wide tables, and external files make querying harder.

UNIQUE enforces uniqueness and FOREIGN KEY enforces referential integrity against the parent table. DEFAULT supplies values, CHECK validates conditions, computed columns do not enforce either rule by themselves, and a plain index does not declare the constraint.

Partitioning by month lets queries touch only relevant partitions, and partition switching moves old data out quickly. Unpartitioned heaps, copies with no indexes, and daily rebuilds are inefficient.

A view encapsulates a query as a named object that can be selected from and joined. Triggers run on data changes, identity columns generate numbers, and check constraints validate values.

A scalar function returns a single value from inputs and can be reused in queries. Triggers respond to data modifications, sequences generate numbers, and indexes improve access paths.

An explicit transaction with error handling commits all or nothing, which keeps the order and lines consistent. Separate statements can leave partial data, and views cannot run inserts or wrap them in transactions.

Window functions compute ranks over partitions while keeping each row. GROUP BY collapses rows, DISTINCT removes duplicates, and unordered subqueries do not produce a correct ranking.

Recursive CTEs have an anchor member and a recursive member, which suits hierarchical traversal. Nested views cannot recurse, and a function without a base case never ends.

Triggering regeneration when text changes keeps the stored vectors aligned with the source. One-time generation leaves stale vectors, per-query computation adds latency, and images lose the text meaning.

Models have input size limits, and focused chunks improve match precision for retrieval. Chunking does not enlarge documents, index needs remain, and the technique applies to text.

Descriptive text carries the meaning that semantic search needs. Row versions, audit timestamps, and random numbers do not describe the product.

Language support determines whether meaning is captured across the content and user queries. Documentation colour, team names, and name length do not affect retrieval quality.

External model objects store the endpoint and configuration once, and queries reference them by name. Comments, spreadsheets, and printed lists do not centralize or manage the configuration.

Vector search compares embeddings, so it finds semantically similar content without requiring shared words. Exact matches, date filters, and sequence lookups rely on literal values.

Hybrid search combines exact keyword matching for codes with semantic matching for meaning. Vector-only search can miss exact codes, full-text alone misses synonyms, and table scans are slow.

RRF combines rankings by rewarding results that rank highly in each list, which avoids mixing incompatible score scales. Raw distances, alphabetical sorting, and single-list picks ignore the other list.

Vector indexes support approximate nearest neighbour search, which trades a small amount of precision for much faster queries. Text indexes, row functions, and exhaustive scans do not provide that speed.

Exact KNN gives perfect recall at the cost of more computation, which suits small or critical searches. Approximate methods are preferred when latency at scale matters more than perfect recall.