Free WGU Data Management - Foundations Exam Dumps July 2026

The BETWEEN keyword in SQL is used to filter values within a specified range. It is particularly useful for numeric and date-based queries.

Syntax of BETWEEN:

sql

SELECT * FROM Employees WHERE Salary BETWEEN 50000 AND 100000;

Retrieves all employees whose salary is between $50,000 and $100,000 (inclusive).

Why Other Options Are Incorrect:

Option A (LIKE) (Incorrect): Used for pattern matching with wildcards (%, _). Example:

sql

SELECT * FROM Customers WHERE Name LIKE 'A%';

Option B (IN) (Incorrect): Used to match a value in a specified set, but not a range. Example:

sql

SELECT * FROM Employees WHERE Department IN ('HR', 'Finance', 'IT');

Option C (OR) (Incorrect): Used for logical conditions, but does not check a range. Example:

sql

SELECT * FROM Products WHERE Price < 10 OR Price > 50;

Thus, the correct choice is BETWEEN for filtering values within a range.

A foreign key is a column (or a set of columns) that establishes a relationship between two tables by referencing the primary key of another table.

Example Usage:

sql

CREATE TABLE Departments (

DeptID INT PRIMARY KEY,

DeptName VARCHAR(50)

);

CREATE TABLE Employees (

EmpID INT PRIMARY KEY,

Name VARCHAR(50),

DeptID INT,

FOREIGN KEY (DeptID) REFERENCES Departments(DeptID)

);

DeptID in Employees is a foreign key, referencing DeptID in Departments.

Ensures referential integrity DeptID in Employees must exist in Departments.

Why Other Options Are Incorrect:

Option A (Super key) (Incorrect): A super key is any set of columns that uniquely identifies a row, but it does not reference another table.

Option B (Simple key) (Incorrect): A simple key is a single-column primary key, not a reference to another table.

Option C (Composite key) (Incorrect): A composite key consists of multiple columns but does not necessarily reference another table.

Thus, the correct answer is Foreign key, as it establishes a connection between two tables.

In database modeling, the relationship between a supertype and its subtypes is called an IsA relationship.

Example Usage:

A Vehicle supertype may have Car and Truck subtypes.

Vehicle

Car

Truck

In ER diagrams, this is represented as:

Vehicle (Supertype)

|

Car (Subtype)

Truck (Subtype)

SQL Table Implementation:

sql

CREATE TABLE Vehicle (

VehicleID INT PRIMARY KEY,

Make VARCHAR(50),

Model VARCHAR(50)

);

CREATE TABLE Car (

VehicleID INT PRIMARY KEY,

FOREIGN KEY (VehicleID) REFERENCES Vehicle(VehicleID),

EngineType VARCHAR(50)

);

CREATE TABLE Truck (

VehicleID INT PRIMARY KEY,

FOREIGN KEY (VehicleID) REFERENCES Vehicle(VehicleID),

CargoCapacity INT

);

This structure preserves the IsA relationship between Vehicle (supertype) and Car/Truck (subtypes).

Why Other Options Are Incorrect:

Option A (Strong entity) (Incorrect): Strong entities do not rely on a supertype/subtype hierarchy.

Option C (Associative entity) (Incorrect): Used to resolve many-to-many relationships, not supertype/subtype relationships.

Option D (Weak entity) (Incorrect): Weak entities depend on a strong entity, but supertype-subtype relations use inheritance (not dependency).

Thus, the correct answer is IsA relationship, as it describes the inheritance hierarchy between supertypes and subtypes.

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.

The correct syntax for inserting a new row into a table follows this structure:

Standard SQL INSERT Syntax:

sql

INSERT INTO TableName (Column1, Column2, ...)

VALUES (Value1, Value2, ...);

For this scenario:

sql

INSERT INTO Employee (Name) VALUES ('John Doe');

Why Other Options Are Incorrect:

Option A (Incorrect): Uses incorrect syntax { ... }, which is not valid SQL syntax.

Option C (Incorrect): Does not specify the column name, which causes an error.

Option D (Incorrect): Misses the INTO keyword, which is required in standard SQL.

Thus, the correct syntax is Option B, ensuring a properly formatted insert statement.

Attributes in a database represent the properties (names, values, or characteristics) of an entity.

Example Usage:

In a Students table, attributes might include:

StudentID (Primary Key), Name, Age, Major

Here, Name is an attribute describing the entity Student.

Why Other Options Are Incorrect:

Option A (Synonyms) (Incorrect): Synonyms in SQL allow different names for the same object but are not attributes.

Option C (Repositories) (Incorrect): A repository stores data but does not define attributes.

Option D (Relationships) (Incorrect): Relationships define connections between entities, not their attributes.

Thus, the correct answer is Names, as attributes define entity properties.