Pass Microsoft Azure Data DP-900 Exam in First Attempt Easily
Real Microsoft Azure Data DP-900 Exam Questions, Accurate & Verified Answers As Experienced in the Actual Test!

Verified by experts
3 products

You save $69.98

DP-900 Premium Bundle

  • Premium File 332 Questions & Answers
  • Last Update: Nov 14, 2026
  • Training Course 32 Lectures
  • Study Guide 672 Pages
$79.99 $149.97

Purchase Individually

  • Premium File

    332 Questions & Answers
    Last Update: Nov 14, 2026

    $76.99
    $69.99
  • Training Course

    32 Lectures

    $43.99
    $39.99
  • Study Guide

    672 Pages

    $43.99
    $39.99

Microsoft Azure Data Fundamentals DP-900 Practice Test 13

Question 120

Each Orders row references a customer that must exist before an order can be inserted. If the team ignores the targeted approach (Enforce a foreign key from Orders.CustomerId to Customers.CustomerId.), which consequence or limitation MOST directly follows from leaving that requirement unaddressed?

  1. Removing referential constraints can create orphaned order rows.
  2. Using a nonunique display name as a row identifier can misidentify customers.
  3. A plain ORDER BY merely sorts detail rows and does not aggregate totals.
  4. Omitting WHERE from an UPDATE can change every row in the table.

Explanation

Correct Answer

A:

Removing referential constraints can create orphaned order rows. This risk follows from the exact scenario: Each Orders row references a customer that must exist before an order can be inserted. The reason is a foreign key constrains references between related tables. The direct mitigation is: Enforce a foreign key from Orders.CustomerId to Customers.CustomerId.

Incorrect Answers

B:

Using a nonunique display name as a row identifier can misidentify customers. This is a real potential problem in a different scenario: A customer table must uniquely identify each customer even when two people have the same display name. The present case instead concerns Each Orders row references a customer that must exist before an order can be inserted. With the targeted action omitted, the direct exposure is Removing referential constraints can create orphaned order rows.

C:

A plain ORDER BY merely sorts detail rows and does not aggregate totals. This is a real potential problem in a different scenario: A report needs total ordered value by product category instead of one row per sales item. The present case instead concerns Each Orders row references a customer that must exist before an order can be inserted. With the targeted action omitted, the direct exposure is Removing referential constraints can create orphaned order rows.

D:

Omitting WHERE from an UPDATE can change every row in the table. This is a real potential problem in a different scenario: An inventory correction must change Quantity for only item 402 without affecting any other item. The present case instead concerns Each Orders row references a customer that must exist before an order can be inserted. With the targeted action omitted, the direct exposure is Removing referential constraints can create orphaned order rows.

Question 121

A customer address is copied into every order and updates leave conflicting addresses in past rows. Which solution or configuration choice MOST directly satisfies the stated requirement without changing unrelated behavior?

  1. Enforce a foreign key from Orders.CustomerId to Customers.CustomerId.
  2. Evaluate an index on the frequently filtered column and confirm its query plan.
  3. Normalize the model by keeping customer attributes in Customers and referencing its key from Orders.
  4. Use UPDATE with a WHERE predicate selecting ItemId 402.

Explanation

Correct Answer

C:

Normalize the model by keeping customer attributes in Customers and referencing its key from Orders. This directly addresses the case: A customer address is copied into every order and updates leave conflicting addresses in past rows. The deciding technical reason is that normalization reduces unnecessary redundancy while preserving relationships. Verify the solution by checking: Changing the current customer address in one row does not leave duplicate current values elsewhere.

Incorrect Answers

A:

Enforce a foreign key from Orders.CustomerId to Customers.CustomerId. This is a legitimate approach for a different problem: Each Orders row references a customer that must exist before an order can be inserted. A foreign key constrains references between related tables. It does not directly satisfy the present constraint: A customer address is copied into every order and updates leave conflicting addresses in past rows. The needed outcome is: Changing the current customer address in one row does not leave duplicate current values elsewhere.

B:

Evaluate an index on the frequently filtered column and confirm its query plan. This is a legitimate approach for a different problem: Queries frequently filter a very large Orders table by OrderDate and scan too many unrelated rows. Indexes improve selective access patterns at a cost to updates and space. It does not directly satisfy the present constraint: A customer address is copied into every order and updates leave conflicting addresses in past rows. The needed outcome is: Changing the current customer address in one row does not leave duplicate current values elsewhere.

D:

Use UPDATE with a WHERE predicate selecting ItemId 402. This is a legitimate approach for a different problem: An inventory correction must change Quantity for only item 402 without affecting any other item. UPDATE modifies existing records and WHERE limits the target set. It does not directly satisfy the present constraint: A customer address is copied into every order and updates leave conflicting addresses in past rows. The needed outcome is: Changing the current customer address in one row does not leave duplicate current values elsewhere.

Question 122

A customer address is copied into every order and updates leave conflicting addresses in past rows. A team proposes: Normalize the model by keeping customer attributes in Customers and referencing its key from Orders. Which observation would BEST demonstrate that this exact requirement was met?

  1. An order with an unknown customer key is rejected while an existing customer key succeeds.
  2. The query plan uses an appropriate index to avoid unnecessary row scanning where beneficial.
  3. Only the intended item's quantity changes after the transaction commits.
  4. Changing the current customer address in one row does not leave duplicate current values elsewhere.

Explanation

Correct Answer

D:

Changing the current customer address in one row does not leave duplicate current values elsewhere. Normalization reduces unnecessary redundancy while preserving relationships. It is tied to this case: A customer address is copied into every order and updates leave conflicting addresses in past rows.

Incorrect Answers

A:

An order with an unknown customer key is rejected while an existing customer key succeeds. This would validate a different scenario: Each Orders row references a customer that must exist before an order can be inserted. The proposed change here is Normalize the model by keeping customer attributes in Customers and referencing its key from Orders. and its decisive acceptance check is Changing the current customer address in one row does not leave duplicate current values elsewhere.

B:

The query plan uses an appropriate index to avoid unnecessary row scanning where beneficial. This would validate a different scenario: Queries frequently filter a very large Orders table by OrderDate and scan too many unrelated rows. The proposed change here is Normalize the model by keeping customer attributes in Customers and referencing its key from Orders. and its decisive acceptance check is Changing the current customer address in one row does not leave duplicate current values elsewhere.

C:

Only the intended item's quantity changes after the transaction commits. This would validate a different scenario: An inventory correction must change Quantity for only item 402 without affecting any other item. The proposed change here is Normalize the model by keeping customer attributes in Customers and referencing its key from Orders. and its decisive acceptance check is Changing the current customer address in one row does not leave duplicate current values elsewhere.

Question 123

During an architecture review, the team proposes: Normalize the model by keeping customer attributes in Customers and referencing its key from Orders. The requirement is: A customer address is copied into every order and updates leave conflicting addresses in past rows. Which technical explanation BEST justifies this specific recommendation?

  1. Normalization reduces unnecessary redundancy while preserving relationships.
  2. A foreign key constrains references between related tables.
  3. Indexes improve selective access patterns at a cost to updates and space.
  4. UPDATE modifies existing records and WHERE limits the target set.

Explanation

Correct Answer

A:

Normalization reduces unnecessary redundancy while preserving relationships. Evidence would be: Changing the current customer address in one row does not leave duplicate current values elsewhere. The choice avoids this risk: Repeating master data across transaction rows creates update anomalies.

Incorrect Answers

B:

A foreign key constrains references between related tables. That principle applies to the separate requirement: Each Orders row references a customer that must exist before an order can be inserted. It may be true in that setting, but does not specifically explain why Normalize the model by keeping customer attributes in Customers and referencing its key from Orders. is the best fit here. The relevant reason is Normalization reduces unnecessary redundancy while preserving relationships.

C:

Indexes improve selective access patterns at a cost to updates and space. That principle applies to the separate requirement: Queries frequently filter a very large Orders table by OrderDate and scan too many unrelated rows. It may be true in that setting, but does not specifically explain why Normalize the model by keeping customer attributes in Customers and referencing its key from Orders. is the best fit here. The relevant reason is Normalization reduces unnecessary redundancy while preserving relationships.

D:

UPDATE modifies existing records and WHERE limits the target set. That principle applies to the separate requirement: An inventory correction must change Quantity for only item 402 without affecting any other item. It may be true in that setting, but does not specifically explain why Normalize the model by keeping customer attributes in Customers and referencing its key from Orders. is the best fit here. The relevant reason is Normalization reduces unnecessary redundancy while preserving relationships.

Question 124

A customer address is copied into every order and updates leave conflicting addresses in past rows. If the team ignores the targeted approach (Normalize the model by keeping customer attributes in Customers and referencing its key from Orders.), which consequence or limitation MOST directly follows from leaving that requirement unaddressed?

  1. Removing referential constraints can create orphaned order rows.
  2. Repeating master data across transaction rows creates update anomalies.
  3. Adding an index indiscriminately can increase write maintenance and storage overhead.
  4. Omitting WHERE from an UPDATE can change every row in the table.

Explanation

Correct Answer

B:

Repeating master data across transaction rows creates update anomalies. This risk follows from the exact scenario: A customer address is copied into every order and updates leave conflicting addresses in past rows. The reason is normalization reduces unnecessary redundancy while preserving relationships. The direct mitigation is: Normalize the model by keeping customer attributes in Customers and referencing its key from Orders.

Incorrect Answers

A:

Removing referential constraints can create orphaned order rows. This is a real potential problem in a different scenario: Each Orders row references a customer that must exist before an order can be inserted. The present case instead concerns A customer address is copied into every order and updates leave conflicting addresses in past rows. With the targeted action omitted, the direct exposure is Repeating master data across transaction rows creates update anomalies.

C:

Adding an index indiscriminately can increase write maintenance and storage overhead. This is a real potential problem in a different scenario: Queries frequently filter a very large Orders table by OrderDate and scan too many unrelated rows. The present case instead concerns A customer address is copied into every order and updates leave conflicting addresses in past rows. With the targeted action omitted, the direct exposure is Repeating master data across transaction rows creates update anomalies.

D:

Omitting WHERE from an UPDATE can change every row in the table. This is a real potential problem in a different scenario: An inventory correction must change Quantity for only item 402 without affecting any other item. The present case instead concerns A customer address is copied into every order and updates leave conflicting addresses in past rows. With the targeted action omitted, the direct exposure is Repeating master data across transaction rows creates update anomalies.

Question 125

A table stores three phone numbers in one comma-separated field but support staff must search an individual number. Which solution or configuration choice MOST directly satisfies the stated requirement without changing unrelated behavior?

  1. Use INSERT INTO with the required column values.
  2. Evaluate an index on the frequently filtered column and confirm its query plan.
  3. Use UPDATE with a WHERE predicate selecting ItemId 402.
  4. Store telephone values atomically in related rows rather than a comma-separated list.

Explanation

Correct Answer

D:

Store telephone values atomically in related rows rather than a comma-separated list. This directly addresses the case: A table stores three phone numbers in one comma-separated field but support staff must search an individual number. The deciding technical reason is that first normal form expects atomic values rather than repeating lists in one column. Verify the solution by checking: A query returns the exact matching telephone value without splitting a single cell.

Incorrect Answers

A:

Use INSERT INTO with the required column values. This is a legitimate approach for a different problem: A support application must add one new record to an existing Orders table. INSERT adds rows to a table while CREATE defines database objects. It does not directly satisfy the present constraint: A table stores three phone numbers in one comma-separated field but support staff must search an individual number. The needed outcome is: A query returns the exact matching telephone value without splitting a single cell.

B:

Evaluate an index on the frequently filtered column and confirm its query plan. This is a legitimate approach for a different problem: Queries frequently filter a very large Orders table by OrderDate and scan too many unrelated rows. Indexes improve selective access patterns at a cost to updates and space. It does not directly satisfy the present constraint: A table stores three phone numbers in one comma-separated field but support staff must search an individual number. The needed outcome is: A query returns the exact matching telephone value without splitting a single cell.

C:

Use UPDATE with a WHERE predicate selecting ItemId 402. This is a legitimate approach for a different problem: An inventory correction must change Quantity for only item 402 without affecting any other item. UPDATE modifies existing records and WHERE limits the target set. It does not directly satisfy the present constraint: A table stores three phone numbers in one comma-separated field but support staff must search an individual number. The needed outcome is: A query returns the exact matching telephone value without splitting a single cell.

Question 126

A table stores three phone numbers in one comma-separated field but support staff must search an individual number. A team proposes: Store telephone values atomically in related rows rather than a comma-separated list. Which observation would BEST demonstrate that this exact requirement was met?

  1. A query returns the exact matching telephone value without splitting a single cell.
  2. The new row appears once without replacing existing orders.
  3. The query plan uses an appropriate index to avoid unnecessary row scanning where beneficial.
  4. Only the intended item's quantity changes after the transaction commits.

Explanation

Correct Answer

A:

A query returns the exact matching telephone value without splitting a single cell. First normal form expects atomic values rather than repeating lists in one column. It is tied to this case: A table stores three phone numbers in one comma-separated field but support staff must search an individual number.

Incorrect Answers

B:

The new row appears once without replacing existing orders. This would validate a different scenario: A support application must add one new record to an existing Orders table. The proposed change here is Store telephone values atomically in related rows rather than a comma-separated list. and its decisive acceptance check is A query returns the exact matching telephone value without splitting a single cell.

C:

The query plan uses an appropriate index to avoid unnecessary row scanning where beneficial. This would validate a different scenario: Queries frequently filter a very large Orders table by OrderDate and scan too many unrelated rows. The proposed change here is Store telephone values atomically in related rows rather than a comma-separated list. and its decisive acceptance check is A query returns the exact matching telephone value without splitting a single cell.

D:

Only the intended item's quantity changes after the transaction commits. This would validate a different scenario: An inventory correction must change Quantity for only item 402 without affecting any other item. The proposed change here is Store telephone values atomically in related rows rather than a comma-separated list. and its decisive acceptance check is A query returns the exact matching telephone value without splitting a single cell.

Question 127

During an architecture review, the team proposes: Store telephone values atomically in related rows rather than a comma-separated list. The requirement is: A table stores three phone numbers in one comma-separated field but support staff must search an individual number. Which technical explanation BEST justifies this specific recommendation?

  1. INSERT adds rows to a table while CREATE defines database objects.
  2. First normal form expects atomic values rather than repeating lists in one column.
  3. Indexes improve selective access patterns at a cost to updates and space.
  4. UPDATE modifies existing records and WHERE limits the target set.

Explanation

Correct Answer

B:

First normal form expects atomic values rather than repeating lists in one column. Evidence would be: A query returns the exact matching telephone value without splitting a single cell. The choice avoids this risk: Multiple values inside one field violate the usual first-normal-form design goal.

Incorrect Answers

A:

INSERT adds rows to a table while CREATE defines database objects. That principle applies to the separate requirement: A support application must add one new record to an existing Orders table. It may be true in that setting, but does not specifically explain why Store telephone values atomically in related rows rather than a comma-separated list. is the best fit here. The relevant reason is First normal form expects atomic values rather than repeating lists in one column.

C:

Indexes improve selective access patterns at a cost to updates and space. That principle applies to the separate requirement: Queries frequently filter a very large Orders table by OrderDate and scan too many unrelated rows. It may be true in that setting, but does not specifically explain why Store telephone values atomically in related rows rather than a comma-separated list. is the best fit here. The relevant reason is First normal form expects atomic values rather than repeating lists in one column.

D:

UPDATE modifies existing records and WHERE limits the target set. That principle applies to the separate requirement: An inventory correction must change Quantity for only item 402 without affecting any other item. It may be true in that setting, but does not specifically explain why Store telephone values atomically in related rows rather than a comma-separated list. is the best fit here. The relevant reason is First normal form expects atomic values rather than repeating lists in one column.

Question 128

A table stores three phone numbers in one comma-separated field but support staff must search an individual number. If the team ignores the targeted approach (Store telephone values atomically in related rows rather than a comma-separated list.), which consequence or limitation MOST directly follows from leaving that requirement unaddressed?

  1. Using CREATE TABLE would create a schema object rather than a business record.
  2. Adding an index indiscriminately can increase write maintenance and storage overhead.
  3. Multiple values inside one field violate the usual first-normal-form design goal.
  4. Omitting WHERE from an UPDATE can change every row in the table.

Explanation

Correct Answer

C:

Multiple values inside one field violate the usual first-normal-form design goal. This risk follows from the exact scenario: A table stores three phone numbers in one comma-separated field but support staff must search an individual number. The reason is first normal form expects atomic values rather than repeating lists in one column. The direct mitigation is: Store telephone values atomically in related rows rather than a comma-separated list.

Incorrect Answers

A:

Using CREATE TABLE would create a schema object rather than a business record. This is a real potential problem in a different scenario: A support application must add one new record to an existing Orders table. The present case instead concerns A table stores three phone numbers in one comma-separated field but support staff must search an individual number. With the targeted action omitted, the direct exposure is Multiple values inside one field violate the usual first-normal-form design goal.

B:

Adding an index indiscriminately can increase write maintenance and storage overhead. This is a real potential problem in a different scenario: Queries frequently filter a very large Orders table by OrderDate and scan too many unrelated rows. The present case instead concerns A table stores three phone numbers in one comma-separated field but support staff must search an individual number. With the targeted action omitted, the direct exposure is Multiple values inside one field violate the usual first-normal-form design goal.

D:

Omitting WHERE from an UPDATE can change every row in the table. This is a real potential problem in a different scenario: An inventory correction must change Quantity for only item 402 without affecting any other item. The present case instead concerns A table stores three phone numbers in one comma-separated field but support staff must search an individual number. With the targeted action omitted, the direct exposure is Multiple values inside one field violate the usual first-normal-form design goal.

Question 129

A helpdesk wants to list only unresolved tickets and display TicketId and OpenedAt without changing data. Which solution or configuration choice MOST directly satisfies the stated requirement without changing unrelated behavior?

  1. Use a SELECT statement with a WHERE filter for unresolved status.
  2. Create a SQL view over the current Customers table with its active filter.
  3. Use a JOIN predicate on the matching customer keys.
  4. Enforce a foreign key from Orders.CustomerId to Customers.CustomerId.

Explanation

Correct Answer

A:

Use a SELECT statement with a WHERE filter for unresolved status. This directly addresses the case: A helpdesk wants to list only unresolved tickets and display TicketId and OpenedAt without changing data. The deciding technical reason is that sELECT reads rows; WHERE restricts which rows qualify. Verify the solution by checking: The query returns the specified columns only for qualifying tickets.

Incorrect Answers

B:

Create a SQL view over the current Customers table with its active filter. This is a legitimate approach for a different problem: A reporting team wants a reusable filtered representation of active customers without copying all customer rows nightly. A standard SQL view stores a query definition over base tables. It does not directly satisfy the present constraint: A helpdesk wants to list only unresolved tickets and display TicketId and OpenedAt without changing data. The needed outcome is: The query returns the specified columns only for qualifying tickets.

C:

Use a JOIN predicate on the matching customer keys. This is a legitimate approach for a different problem: An analyst needs customers and their invoices in one result, matched by CustomerId across two tables. SQL JOIN relates matching rows from separate tables. It does not directly satisfy the present constraint: A helpdesk wants to list only unresolved tickets and display TicketId and OpenedAt without changing data. The needed outcome is: The query returns the specified columns only for qualifying tickets.

D:

Enforce a foreign key from Orders.CustomerId to Customers.CustomerId. This is a legitimate approach for a different problem: Each Orders row references a customer that must exist before an order can be inserted. A foreign key constrains references between related tables. It does not directly satisfy the present constraint: A helpdesk wants to list only unresolved tickets and display TicketId and OpenedAt without changing data. The needed outcome is: The query returns the specified columns only for qualifying tickets.

Question 130

A helpdesk wants to list only unresolved tickets and display TicketId and OpenedAt without changing data. A team proposes: Use a SELECT statement with a WHERE filter for unresolved status. Which observation would BEST demonstrate that this exact requirement was met?

  1. Selecting the view returns current qualifying customers after base records change.
  2. The query returns the specified columns only for qualifying tickets.
  3. Each invoice row is combined with the corresponding customer without guessing name equality.
  4. An order with an unknown customer key is rejected while an existing customer key succeeds.

Explanation

Correct Answer

B:

The query returns the specified columns only for qualifying tickets. SELECT reads rows; WHERE restricts which rows qualify. It is tied to this case: A helpdesk wants to list only unresolved tickets and display TicketId and OpenedAt without changing data.

Incorrect Answers

A:

Selecting the view returns current qualifying customers after base records change. This would validate a different scenario: A reporting team wants a reusable filtered representation of active customers without copying all customer rows nightly. The proposed change here is Use a SELECT statement with a WHERE filter for unresolved status. and its decisive acceptance check is The query returns the specified columns only for qualifying tickets.

C:

Each invoice row is combined with the corresponding customer without guessing name equality. This would validate a different scenario: An analyst needs customers and their invoices in one result, matched by CustomerId across two tables. The proposed change here is Use a SELECT statement with a WHERE filter for unresolved status. and its decisive acceptance check is The query returns the specified columns only for qualifying tickets.

D:

An order with an unknown customer key is rejected while an existing customer key succeeds. This would validate a different scenario: Each Orders row references a customer that must exist before an order can be inserted. The proposed change here is Use a SELECT statement with a WHERE filter for unresolved status. and its decisive acceptance check is The query returns the specified columns only for qualifying tickets.

Microsoft Azure Data Fundamentals (DP-900) Practice Tests

Purchase Individually

  • Premium File

    332 Questions & Answers
    Last Update: Nov 14, 2026

    $76.99
    $69.99
  • Training Course

    32 Lectures

    $43.99
    $39.99
  • Study Guide

    672 Pages

    $43.99
    $39.99

SPECIAL OFFER: GET 10% OFF
This is ONE TIME OFFER

You save
10%

Enter Your Email Address to Receive Your 10% Off Discount Code

SPECIAL OFFER: GET 10% OFF

You save
10%

Use Discount Code:

A confirmation link was sent to your e-mail.

Please check your mailbox for a message from support@examlabs.com and follow the directions.

Download Free Demo of VCE Exam Simulator

Experience Avanset VCE Exam Simulator for yourself.

Simply submit your email address below to get started with our interactive software demo of your free trial.

  • Realistic exam simulation and exam editor with preview functions
  • Whole exam in a single file with several different question types
  • Customizable exam-taking mode & detailed score reports