WGU Data-Management-Foundations Exam Dumps

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.

The HAVING clause is used in SQL to filter grouped results generated by the GROUP BY clause. Unlike WHERE, which filters individual rows before grouping, HAVING filters after aggregation has been performed.

Example Usage:

sql

SELECT Department, AVG(Salary) AS AvgSalary

FROM Employees

GROUP BY Department

HAVING AVG(Salary) > 50000;

This query first groups employees by Department, calculates the average salary per department, and then filters only those departments where the average salary is greater than 50,000.

Why Other Options Are Incorrect:

Option A (REPLACE) (Incorrect): Used for string substitution, not filtering.

Option C (WITH) (Incorrect): Used in Common Table Expressions (CTEs), not for filtering.

Option D (WHERE) (Incorrect): Used for row-level filtering before aggregation, but it cannot be used on aggregate functions like SUM() or AVG().

Thus, HAVING is the correct answer for filtering after grouping.

A reflexive relationship (also called a unary relationship) occurs when an entity is related to itself.

Example Usage:

CREATE TABLE Employees (

EmpID INT PRIMARY KEY,

Name VARCHAR(50),

ManagerID INT,

FOREIGN KEY (ManagerID) REFERENCES Employees(EmpID)

);

ManagerID refers to another employee within the same table.

Why Other Options Are Incorrect:

Option A (Repository) (Incorrect): A data storage structure, not a relationship type.

Option B (Relationship instance) (Incorrect): Describes a specific connection between entities, not a reflexive relationship.

Option D (Attribute) (Incorrect): Attributes store characteristics, but do not define relationships.

Thus, the correct answer is Reflexive relationship, as it relates an entity to itself.

The LTRIM() function in SQL removes leading spaces (spaces at the beginning of a string) while keeping spaces at the end.

Example Usage:

sql

SELECT LTRIM(' Hello World') AS TrimmedText;

Output:

bash

'Hello World'

Why Other Options Are Incorrect:

Option B (LEFT) (Incorrect): Used for extracting a portion of a string. Example:

sql

SELECT LEFT('Hello World', 5); -- Output: 'Hello'

Option C (TRIM) (Incorrect): Removes both leading and trailing spaces, not just leading ones. Example:

sql

SELECT TRIM(' Hello World '); -- Output: 'Hello World'

Option D (REPLACE) (Incorrect): Replaces occurrences of one substring with another but does not specifically remove spaces.

Thus, the correct answer is LTRIM(), which removes only leading spaces.

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.