Important WGU Data Management - Foundations Exam Questions

Answer: B

Explanation:

Binary search is an algorithm that finds a search value by repeatedly dividing the search space into two halves. It is commonly used in indexed searches.

Example Usage in Databases:

B-Trees and B+ Trees (used in database indexing) apply binary search to navigate the index efficiently.

If searching for ID = 50 in a sorted list of IDs, binary search:

Splits the list into two halves.

Checks the middle value.

Eliminates half of the dataset.

Repeats until the value is found.

Why Other Options Are Incorrect:

Option A (Table scan) (Incorrect): Reads every row, much slower than binary search.

Option C (Index scan) (Incorrect): Uses indexes but does not necessarily apply binary search.

Option D (Fan-out) (Incorrect): Describes branching in B-Trees, not searching.

Thus, the correct answer is Binary search, as it repeatedly splits the index in two.

Answer: D

Explanation:

In a one-to-many (1:M) relationship, the foreign key is placed in the table on the 'many' side to establish the relationship with the primary key of the 'one' side.

Example Usage:

CREATE TABLE Departments (

DeptID INT PRIMARY KEY,

DeptName VARCHAR(50)

);

CREATE TABLE Employees (

EmpID INT PRIMARY KEY,

Name VARCHAR(50),

DeptID INT, -- Foreign key on the 'many' side

FOREIGN KEY (DeptID) REFERENCES Departments(DeptID)

);

Each department can have many employees DeptID is a foreign key in Employees.

Why Other Options Are Incorrect:

Option A (Reflexive relationship) (Incorrect): Refers to unary (self-referential) relationships, not 1:M relationships.

Option B (Binary relationship) (Incorrect): A binary relationship involves two entities, but does not define where the foreign key is stored.

Option C (Weak entity) (Incorrect): Weak entities depend on a strong entity, but not all 'many' sides are weak entities.

Thus, the correct answer is Foreign key, as it is placed on the 'many' side of the relationship.

Answer: B

Explanation:

The logical design phase in database development focuses on structuring data efficiently to eliminate redundancy and ensure integrity. The final step in logical design is to apply normalization (normal forms) to optimize the database schema.

Steps in Logical Database Design:

Discover entities Identify real-world objects (e.g., Customers, Orders).

Determine cardinality Define relationships between entities (one-to-one, one-to-many).

Analyze data requirements Determine the attributes each entity needs.

Apply normal forms Eliminate redundancy and improve data consistency.

Example Usage:

After identifying entities like Students and Courses, applying 3rd Normal Form (3NF) ensures that data is organized without redundancy.

Why Other Options Are Incorrect:

Option A (Analyze data requirements) (Incorrect): Done earlier to define attributes.

Option C (Determine cardinality) (Incorrect): Done before normalization to establish relationships.

Option D (Discover entities) (Incorrect): Done at the beginning of database design.

Thus, the correct answer is Apply a normal form, as normalization is the last step in logical design.

Answer: B

Explanation:

The second step in implementing relationships is defining one-to-one (1:1) relationships between entities.

Example Usage:

Example of a 1:1 relationship:

sql

CREATE TABLE Employees (

EmpID INT PRIMARY KEY,

Name VARCHAR(50)

);

CREATE TABLE EmployeeDetails (

EmpID INT PRIMARY KEY,

Address VARCHAR(255),

FOREIGN KEY (EmpID) REFERENCES Employees(EmpID)

);

Here, each employee has exactly one detail record, creating a 1:1 relationship.

Why Other Options Are Incorrect:

Option A (Implement weak entities) (Incorrect): Weak entities rely on a foreign key and are implemented later.

Option C (Implement subtype entities) (Incorrect): Subtypes are special cases and not implemented in the second step.

Option D (Specify cascade) (Incorrect): Cascade rules (ON DELETE, ON UPDATE) are defined during foreign key implementation, not in the second step.

Thus, the correct answer is Implement one-one relationships, as it is the next logical step after defining entities.

Answer: C

Explanation:

The % operator in MySQL is known as the modulus operator. It returns the remainder of a division operation between two numbers.

Example:

sql

SELECT 10 % 3; -- Output: 1 (10 divided by 3 gives remainder 1)

Option A (Incorrect): Raising a number to a power is done using the POW() function or ^ in some SQL dialects.

Option B (Incorrect): The = operator is used for equality comparisons, not %.

Option C (Correct): The modulus operator (%) finds the remainder when one number is divided by another.

Option D (Incorrect): Subtraction is performed using the - operator.