IT Certifications · 70-768

Exam 70-768: Developing SQL Data Models Practice Test

Exam 70-768: Developing SQL Data Models concerns relational database design and SQL Server data-model implementation. The available practice material uses concepts such as keys and constraints, normalization, identity columns, data types, indexes, joins, and views. These topics connect logical data requirements to structures that support accurate storage, enforce relationships, and make information easier to query.

Exam overview

Exam providerMicrosoft
Exam code70-768
CategoryIT Certifications

About the Exam 70-768: Developing SQL Data Models Exam

Modeling decisions affect data integrity, update behavior, and query access. Practice with primary and composite keys, unique constraints, and foreign keys to distinguish row identification from relationship enforcement. Normalization scenarios call for recognizing redundancy and update anomalies, then separating entities so shared attributes are maintained consistently. SQL Server implementation concepts include choosing suitable column types, using identity properties for generated values, and selecting clustered or nonclustered indexes based on access patterns and existing table structure. Query-related scenarios may require joining tables with equality or range predicates and using views to present selected data without duplicating it. These skills support translating requirements into maintainable relational structures and evaluating the consequences of design choices for inserts, updates, and lookups.

Sample Practice Questions

Review a selection from this exam's published US Practice Tests practice bank.

Question 1

A table's primary key consists of OrderID and LineNumber. Which statement best describes this key?

  1. AIt permits multiple rows with the same pair of values if LineNumber is not NULL
  2. BIt identifies each row using the combination of both columns
  3. CIt requires OrderID to be a foreign key
  4. DIt automatically creates a separate table for line numbers
Show answerCorrect answer: B

A composite primary key uses multiple columns together to identify a row uniquely. The combination must be unique, and primary-key columns cannot be NULL.

Question 2

An application must represent a value that can have one of several named states, such as Draft, Approved, or Rejected. The allowed states may be added over time and need descriptive attributes. Which modeling approach is most flexible?

  1. ACreate a state lookup table and reference it with a foreign key
  2. BStore the state description as a floating-point number
  3. CUse a separate table for every possible state
  4. DEncode the state in the table name
Show answerCorrect answer: A

A lookup table provides a controlled set of state values, can store descriptions or other attributes, and can be extended by adding rows. A foreign key can ensure that each stored state refers to a defined value.

Question 3

A SQL Server table needs a generated identifier that increases automatically when a new row is inserted. Which column property is designed for this purpose?

  1. AIDENTITY
  2. BCHECK
  3. CSPARSE
  4. DROWGUIDCOL
Show answerCorrect answer: A

The IDENTITY property generates numeric values for inserted rows according to a seed and increment. CHECK validates a condition, SPARSE can optimize storage of NULL values, and ROWGUIDCOL identifies a column designated for row GUID values but does not itself generate them.

Question 4

A database stores an employee's department name in every employee row. Department names are sometimes updated, and the change must be made in many rows. Which normalization improvement most directly addresses this update anomaly?

  1. ACreate a Departments table and reference it from Employees
  2. BAdd another copy of the department name to Employees
  3. CConvert the department name to a computed column
  4. DCreate a clustered index on the department name
Show answerCorrect answer: A

Separating department facts into a Departments table avoids repeatedly storing and updating the same department name. Employees can reference the department through a foreign key.

Question 5

A SQL Server model needs to ensure that every value in a column matches a row in a separate lookup table. What is the most direct way to enforce this rule?

  1. ACreate a foreign key referencing the lookup table
  2. BCreate a nonclustered index on the column
  3. CAdd a default constraint to the column
  4. DCreate a view that joins the tables
Show answerCorrect answer: A

A foreign key enforces referential integrity by requiring each non-NULL referencing value to match a key in the referenced table.

Question 6

A SQL Server query must combine rows from two tables based on a relationship that is not equality, such as a date falling between a start date and an end date. Which join condition supports this?

  1. AA join with a range predicate in the ON clause
  2. BA CROSS JOIN with no filter
  3. CA NATURAL JOIN
  4. DA join that requires a foreign key constraint
Show answerCorrect answer: A

The ON clause can use comparison predicates such as BETWEEN or paired inequalities, so matching need not be based on equality. A foreign key is a schema constraint and is not required for the query join itself.

Question 7

A SQL Server table stores one row per customer. Which constraint is the most direct way to ensure that each customer has a unique, non-null identifier?

  1. AA CHECK constraint on the identifier
  2. BA PRIMARY KEY constraint on the identifier
  3. CA DEFAULT constraint on the identifier
  4. DA FOREIGN KEY constraint on the identifier
Show answerCorrect answer: B

A primary key uniquely identifies each row and does not allow NULL values. CHECK and DEFAULT constraints serve other purposes, while a foreign key enforces a relationship to another table.

How to use this practice test

The free US Practice Tests practice bank contains 50 questions; each session presents up to 20 randomly selected questions. Answer a session to see results, then use missed or uncertain items to identify concepts to revisit, such as key design, normalization, constraints, index selection, and joins.

Preparation tips

  • For each key scenario, distinguish a single-column key from a composite key and check whether uniqueness and non-nullability are both required.
  • Practice tracing update anomalies caused by repeated attributes, then sketch a normalized design that stores each fact in an appropriate table.
  • Match SQL Server column requirements to data types and properties, including variable-length large character data and automatically generated identifiers.
  • Compare clustered and nonclustered index choices against the table’s existing index and the lookup pattern described.
  • Write join predicates for both equality relationships and range conditions, and distinguish a view from a separate copied data set.
Official sourceOfficial exam page ↗