WGU Data-Management-Foundations Dumps - Pass WGU Data Management - Foundations Exam in First Attempt 2026

The given diagram represents a unary relationship (also called a recursive relationship), which occurs when an entity is related to itself. In this case, salespersons back each other up, meaning a salesperson is associated with another salesperson from the same entity.

Key Observations from the Diagram:

Single Entity (Salesperson)

The table contains only one entity type, Salesperson, which has attributes such as Salesperson Number, Name, Commission, Percentage, and Year of Hire.

Self-Referencing Relationship (Backs-up and Backed-up by)

The diagram shows that a salesperson can back up another salesperson.

This means that the relationship exists within the same entity rather than between two different entities.

Cardinality (One-to-One Relationship in a Unary Form)

The notation ( |---| ) in the ER diagram indicates a one-to-one recursive relationship.

One salesperson can back up only one other salesperson, and each salesperson is backed up by only one.

When a VIEW is created in SQL, users may insert or update data through that view. However, if a row is inserted or updated in such a way that it violates the condition of the VIEW's WHERE clause, it can lead to inconsistencies.

To prevent such unwanted modifications, SQL provides the WITH CHECK OPTION clause.

How WITH CHECK OPTION Works:

Ensures that any new data (INSERT/UPDATE) still fits within the defined constraints of the VIEW.

If a user tries to insert or update a row that would not appear in the VIEW, the operation is rejected.

Example:

sql

CREATE VIEW HighSalaryEmployees AS

SELECT * FROM Employees WHERE Salary > 50000

WITH CHECK OPTION;

Now, if someone attempts:

sql

INSERT INTO HighSalaryEmployees (ID, Name, Salary)

VALUES (101, 'Alice', 30000);

This fails because 30000 does not satisfy Salary > 50000.

Why Other Options Are Incorrect:

Option B (Incorrect): JOIN VIEWS is not a valid SQL clause.

Option C (Incorrect): MATERIALIZED VIEW refers to stored views in some databases, but it does not reject incorrect inserts/updates.

Option D (Incorrect): BASE TABLE refers to the original table from which a VIEW is created.

Thus, the correct answer is WITH CHECK OPTION, which ensures that only valid data modifications occur.

A primary key uniquely identifies each row in a table. When a primary key consists of only one field, it is called a Simple Primary Key.

Types of Primary Keys:

Simple Primary Key (Correct Answer):

Contains only one column.

Example:

sql

CREATE TABLE Students (

StudentID INT PRIMARY KEY,

Name VARCHAR(50)

);

Composite Primary Key:

Uses multiple columns to ensure uniqueness.

Example:

sql

CREATE TABLE Orders (

OrderID INT,

ProductID INT,

PRIMARY KEY (OrderID, ProductID)

);

Surrogate Primary Key:

A system-generated unique identifier (e.g., UUID or AUTO_INCREMENT).

Why Other Options Are Incorrect:

Option B (Duplicate) (Incorrect): A primary key must be unique, so it cannot be duplicate.

Option C (Numeric) (Incorrect): While primary keys can be numeric, they can also be alphanumeric (VARCHAR).

Option D (Composite) (Incorrect): A composite key consists of multiple fields, whereas a simple key is a single field.

Thus, the correct answer is Simple, since a one-field primary key is a simple primary key.

Aggregate functions perform calculations on a set of values and return a single result. MAX() is one such function, returning the largest value in a column.

Common Aggregate Functions:

Example Usage:

sql

SELECT MAX(Salary) FROM Employees;

Retrieves the highest salary in the Employees table.

Why Other Options Are Incorrect:

Option B (TRIM) (Incorrect): Removes spaces from strings but is not an aggregate function.

Option C (ABS) (Incorrect): Returns the absolute value of a number but does not aggregate multiple rows.

Option D (DESC) (Incorrect): Used in ORDER BY for sorting in descending order, not for aggregation.

Thus, the correct answer is MAX(), as it is a true aggregate function.

The WHERE clause is used in SQL SELECT statements to limit the number of rows that match a specific condition. It helps filter data based on given criteria before retrieving the results.

Example Usage:

sql

SELECT *

FROM Employees

WHERE Salary > 50000;

This query limits the result set to employees whose salary is greater than 50,000.

Why Other Options Are Incorrect:

Option A (FROM) (Incorrect): Specifies the table from which data is retrieved but does not limit results.

Option B (DROP) (Incorrect): Used for deleting tables, databases, or views, not filtering rows.

Option C (INTO) (Incorrect): Used in statements like INSERT INTO or SELECT INTO, which do not filter results.

Thus, WHERE is the correct keyword for applying a limiter in a SELECT statement.