WGU D427 Data Management Applications
OA Exam & Study Guide — 200 Verified Questions with Detailed Rationales
Latest 2026/2027 Actual Exam Questions and Correct Detailed Answers | Already Graded A+
Aligned with WGU D427 Curriculum, OA Blueprint, and MySQL SQL Standards
Examination Overview: This comprehensive 200-question study guide covers the full WGU D427 Data Management
Applications curriculum and Objective Assessment (OA) blueprint. Content spans SQL fundamentals and query execution
(SELECT, WHERE, ORDER BY, LIKE wildcards, aggregate functions COUNT/SUM/AVG/MAX/MIN, GROUP BY,
HAVING, LIMIT, MySQL integer/decimal division); data types, constraints, and table creation (VARCHAR vs CHAR,
INT vs INT UNSIGNED, DECIMAL(p,s), DATE vs DATETIME, CREATE TABLE, ALTER TABLE, PRIMARY KEY,
FOREIGN KEY, NOT NULL, UNIQUE, CHECK, AUTO_INCREMENT, referential integrity actions
RESTRICT/CASCADE/SET NULL); data manipulation and transaction control (INSERT, UPDATE, DELETE, DDL vs
DML, COMMIT, ROLLBACK, BEGIN, SAVEPOINT, ACID properties); joins and subqueries (INNER, LEFT, RIGHT,
FULL OUTER JOIN, self-joins, CROSS JOIN, scalar and correlated subqueries, IN, EXISTS, ANY, ALL,
UNION/UNION ALL, CTEs); database design and normalization (ER modeling, entities, attributes, relationships, 1NF,
2NF, 3NF, BCNF, functional dependencies, candidate keys, anomalies, denormalization, surrogate vs natural keys,
junction tables); views, indexes, and advanced SQL (CREATE VIEW, CREATE INDEX, composite/covering/filtered
indexes, stored procedures, triggers, query optimization, EXPLAIN, join strategies, transaction isolation levels,
phantom/dirty/non-repeatable reads); and integrated SQL scenarios (multi-table joins, aggregations, relational division,
complex subqueries, real-world database applications). Each question includes the correct answer marked [CORRECT]
and a detailed rationale with database management reasoning. Cognitive distribution: 30% recall, 50% application, 20%
analysis. Question style: 75% scenario-based, 25% direct recall. High-yield topics include WHERE vs HAVING,
COUNT(*) vs COUNT(column) NULL handling, JOIN type selection, MySQL division behavior (/ returns decimal, DIV
returns integer), normalization level identification, referential integrity actions, DDL vs DML classification, and functional
dependency analysis.
Section 1: SQL Fundamentals & Query Execution
Q1: A database administrator writes a SELECT statement to retrieve all columns from the 'employees' table
for employees hired after January 1, 2023, sorted by last name in ascending order. Which SQL clause
correctly performs the default ascending sort?
A. ORDER BY last_name DESC;
B. ORDER BY last_name; (ASC is the default and may be omitted) [CORRECT]
C. SORT BY last_name ASC;
D. ORDER last_name ASCENDING;
Correct Answer: B
Rationale: The ORDER BY clause sorts result sets, with ASC (ascending) as the default — it can be omitted. DESC reverses the
order. 'SORT BY' is not valid SQL syntax, and 'ORDER' alone is incomplete. The clause must use 'ORDER BY ' with optional
ASC/DESC keyword.
Q2: A query must return only employees whose last_name begins with 'Sm' (such as Smith, Smyth, Small).
Which LIKE pattern is correct?
A. WHERE last_name LIKE 'Sm%'; (% matches zero or more characters) [CORRECT]
B. WHERE last_name LIKE '%Sm';
D427 OA Prep — For Educational Use Page 1
,WGU D427 Data Management Applications — OA Exam & Study Guide 2026/2027 Latest — 200 Verified Questions
C. WHERE last_name LIKE '_Sm_';
D. WHERE last_name LIKE 'Sm_';
Correct Answer: A
Rationale: In SQL LIKE patterns, '%' matches zero or more characters, while '_' matches exactly one character. 'Sm%' matches
any string starting with 'Sm' followed by zero or more characters (Smith, Smyth, Small). '%Sm' matches strings ENDING in 'Sm'.
'Sm_' matches exactly 3-character strings starting with 'Sm'. '_Sm_' matches 5-character strings with 'Sm' in positions 2-3.
Q3: A developer needs to count all rows in the 'orders' table, including rows where customer_id is NULL.
Which query is correct?
A. SELECT COUNT(customer_id) FROM orders;
B. SELECT COUNT(*) FROM orders; (COUNT(*) counts all rows including NULLs) [CORRECT]
C. SELECT COUNT(DISTINCT customer_id) FROM orders;
D. SELECT SUM(1) WHERE customer_id IS NOT NULL;
Correct Answer: B
Rationale: COUNT(*) counts ALL rows in the table, including rows with NULL values in any column. COUNT(column_name)
counts only non-NULL values in the specified column. COUNT(DISTINCT column) counts unique non-NULL values. For a total
row count, COUNT(*) is the standard and most reliable choice. This distinction is heavily tested on the WGU D427 OA.
Q4: An analyst writes: SELECT COUNT(email) FROM customers; The result is 145, but the table has 200
rows. What explains the difference?
A. The query has a syntax error.
B. COUNT(email) excludes rows where email is NULL; 55 customers have NULL email values. [CORRECT]
C. COUNT automatically removes duplicates.
D. The query implicitly filters by primary key.
Correct Answer: B
Rationale: COUNT(column_name) counts only non-NULL values in the specified column. Of the 200 rows, 55 have NULL email
values, so COUNT(email) returns 145. To count all rows including NULLs, use COUNT(*). To count unique non-NULL emails,
use COUNT(DISTINCT email). Understanding NULL handling in aggregate functions is a high-yield D427 concept.
Q5: A query must list products with a price greater than $50 AND either category 'Electronics' OR category
'Books'. Which WHERE clause is syntactically correct and logically accurate?
A. WHERE price > 50 AND category = 'Electronics' OR category = 'Books';
B. WHERE price > 50 AND (category = 'Electronics' OR category = 'Books'); (parentheses enforce intended
precedence) [CORRECT]
C. WHERE (price > 50 AND category = 'Electronics' OR category = 'Books');
D. WHERE price > 50 OR category = 'Electronics' AND category = 'Books';
Correct Answer: B
Rationale: AND has higher precedence than OR. Without parentheses, option A would be evaluated as (price>50 AND
category='Electronics') OR (category='Books'), returning all books regardless of price. Parentheses in option B correctly
enforce price>50 AND (Electronics OR Books). Option C has misplaced parentheses. Option D returns books that are also
electronics (impossible).
Q6: A query uses: SELECT department, COUNT(*) FROM employees GROUP BY department HAVING
COUNT(*) > 5; Which clause filters BEFORE grouping, and which filters AFTER?
A. GROUP BY filters before; HAVING filters before.
B. WHERE filters individual rows BEFORE grouping; HAVING filters groups AFTER grouping. [CORRECT]
D427 OA Prep — For Educational Use Page 2
,WGU D427 Data Management Applications — OA Exam & Study Guide 2026/2027 Latest — 200 Verified Questions
C. HAVING filters before; WHERE filters after.
D. Both filter at the same stage.
Correct Answer: B
Rationale: WHERE filters individual rows BEFORE grouping (and before aggregate functions are computed). HAVING filters
groups AFTER grouping and after aggregates are computed. HAVING can reference aggregate functions (COUNT, SUM, AVG);
WHERE cannot. This distinction is one of the most frequently tested topics on the WGU D427 OA.
Q7: In MySQL, what is the result of: SELECT ; (integer division behavior)?
A. 3 (integer division returns integer)
B. 3.5 (MySQL / always returns decimal) [CORRECT]
C. 4 (rounds to nearest integer)
D. Error — type mismatch.
Correct Answer: B
Rationale: In MySQL, the '/' operator always performs division and returns a DECIMAL result, so 7/2 = 3.5000. To perform
integer (truncating) division in MySQL, use DIV operator: 7 DIV 2 = 3. This differs from some other RDBMS (e.g., PostgreSQL,
SQL Server) where integer/integer yields integer. WGU D427 uses MySQL-specific behavior for the OA.
Q8: A developer writes: SELECT 7 DIV 2; in MySQL. What is the result?
A. 3.5
B. 3 (DIV performs integer division, truncating the decimal) [CORRECT]
C. 4
D. Error — DIV is not a valid operator.
Correct Answer: B
Rationale: In MySQL, the DIV operator performs integer division and returns an integer result (truncated, not rounded). 7 DIV 2
= 3. The '/' operator returns a decimal. Knowing the difference between / (decimal) and DIV (integer) is MySQL-specific and
tested on D427. DIV is equivalent to FLOOR(/) for positive numbers.
Q9: A query must retrieve the top 10 highest-paid employees from the 'employees' table. Which clause limits
the result set?
A. TOP 10
B. LIMIT 10 (MySQL syntax for restricting rows returned) [CORRECT]
C. ROWNUM <= 10
D. FETCH FIRST 10
Correct Answer: B
Rationale: MySQL uses LIMIT to restrict the number of rows returned. The query would be: SELECT * FROM employees
ORDER BY salary DESC LIMIT 10;. SQL Server uses TOP 10, Oracle uses ROWNUM <= 10 (or FETCH FIRST), and
PostgreSQL/standard SQL uses FETCH FIRST n ROWS ONLY. WGU D427 uses MySQL syntax.
Q10: An analyst writes: SELECT category, AVG(price) FROM products GROUP BY category HAVING
AVG(price) > 100; Why can't the WHERE clause be used instead of HAVING here?
A. WHERE can be used; the query is incorrect.
B. WHERE cannot reference aggregate functions like AVG(); HAVING is designed to filter groups based on
aggregates. [CORRECT]
C. WHERE is faster than HAVING.
D. HAVING is only used with JOIN.
Correct Answer: B
D427 OA Prep — For Educational Use Page 3
, WGU D427 Data Management Applications — OA Exam & Study Guide 2026/2027 Latest — 200 Verified Questions
Rationale: WHERE filters individual rows BEFORE grouping and cannot reference aggregate functions. HAVING filters groups
AFTER grouping and CAN reference aggregates (COUNT, SUM, AVG, MIN, MAX). To filter categories with average price >
100, HAVING is required. WHERE would be used to filter individual products before computing the average per category.
Q11: Which SQL clause is used to filter rows returned by a SELECT statement based on a condition?
A. GROUP BY
B. WHERE (filters rows before grouping) [CORRECT]
C. HAVING
D. ORDER BY
Correct Answer: B
Rationale: WHERE filters individual rows returned by a SELECT statement before any grouping or aggregation. GROUP BY
groups rows, HAVING filters groups (after aggregation), and ORDER BY sorts the result set. WHERE cannot reference
aggregate functions; that's the role of HAVING. WHERE is fundamental SQL and heavily tested on D427.
Q12: Which of the following aggregate functions ignores NULL values?
A. COUNT(*)
B. SUM, AVG, MAX, MIN, and COUNT(column) all ignore NULL values; only COUNT(*) includes NULL rows.
[CORRECT]
C. All aggregates include NULLs.
D. Only COUNT includes NULLs.
Correct Answer: B
Rationale: COUNT(*) counts all rows including NULLs. All other aggregates — COUNT(column), SUM, AVG, MAX, MIN —
ignore NULL values. AVG only averages non-NULL values, SUM only adds non-NULL values, and so on. NULL handling in
aggregates is a critical D427 concept because it affects query results and business logic interpretation.
Q13: Given a table 'sales' with columns (id, amount, region), which query correctly calculates the total sales
amount for each region, sorted by total descending?
A. SELECT region, SUM(amount) FROM sales ORDER BY amount DESC;
B. SELECT region, SUM(amount) AS total FROM sales GROUP BY region ORDER BY total DESC; [CORRECT]
C. SELECT region, SUM(amount) FROM sales GROUP BY region ORDER BY region DESC;
D. SELECT SUM(amount) FROM sales GROUP BY region ORDER BY amount DESC;
Correct Answer: B
Rationale: To calculate total sales per region: (1) SELECT region and SUM(amount); (2) GROUP BY region (so SUM
aggregates per region); (3) ORDER BY the aggregate (or its alias) DESC. Option A lacks GROUP BY (error in standard SQL).
Option C sorts by region, not by total. Option D omits region from SELECT. Aliasing the aggregate (AS total) allows it to be
referenced in ORDER BY.
Q14: A query must find customers whose phone number is exactly 10 digits. Which LIKE pattern matches a
10-character string of any characters?
A. LIKE '%10%'
B. LIKE '__________' (10 underscores, each matches exactly one character) [CORRECT]
C. LIKE '[0-9]{10}'
D. LIKE '%%%%%%%%%%'
Correct Answer: B
Rationale: In LIKE patterns, '_' matches exactly ONE character. Ten underscores match exactly 10 characters (of any kind). '%'
matches zero or more characters (so 10 '%' characters would match strings of any length, not just 10). Regex-style patterns like
[0-9]{10} are NOT supported in standard LIKE (some RDBMS support REGEXP_LIKE or REGEXP). To validate numeric-only,
D427 OA Prep — For Educational Use Page 4