WGU Data-Management-Foundations WGU Data Management – Foundations Exam Exam Practice Test

Anaggregate functionperforms acalculation over multiple rowsand returns asingle value. Examples includeSUM(), AVG(), MAX(), MIN(), and COUNT()in SQL.

Option A (Correct):Aggregate functions compute values over aset of rows, like summingtotal sales or averaging grades.

Option B (Incorrect):Selecting rows that appear in one table but not another is done usingset operations (EXCEPT or MINUS in SQL).

Option C (Incorrect):Eliminating columns is done using thePROJECToperation orSELECT with specific columns.

Option D (Incorrect):Combining rows from two tables refers to aJOIN operation, not aggregation.

Analiasis used in SQL to give atemporaryname to a table or column within a query. It makes queries more readable and helps in cases where a table needs to be referenced multiple times (e.g., in aself-join).

Example Usage:

sql

SELECT e.Name, d.DepartmentName

FROM Employees AS e

JOIN Departments AS d

ON e.DeptID = d.ID;

Here,Employees is aliased as eandDepartments as d, making the query shorter and clearer.

Why Other Options Are Incorrect:

Option A (HAVING) (Incorrect):Used to filter grouped results, not create aliases.

Option B (NEW) (Incorrect):Not a valid SQL keyword for aliasing.

Option D (UNION) (Incorrect):Combines result sets but does not rename tables.

Thus, the correct answer isALIAS, which allows fortemporary naming of tables or columns.

Toadd a primary key constraint after table creation, we use theALTER TABLEstatement.

Example Usage:

sql

ALTER TABLE Employees

ADD CONSTRAINT PK_Employees PRIMARY KEY (EmpID);

Thisaddsa primary key to the EmpID columnafter the table was created.

Why Other Options Are Incorrect:

Option B (CREATE TABLE) (Incorrect):Used for defining constraintsduringtable creation, not after.

Option C (UPDATE) (Incorrect):Modifiesrow values, not constraints.

Option D (INSERT INTO) (Incorrect):Used toadd datato a table, not modify constraints.

Thus, the correct answer isALTER TABLE, as itmodifies table structure to add a primary key constraint.

ATransaction ManagerensuresACID (Atomicity, Consistency, Isolation, Durability)properties in database transactions. It manages concurrent transactions, ensuring no conflicts occur and logs modifications to support recovery mechanisms.

Option A (Incorrect):Query optimization is managed by thequery processor, not the transaction manager.

Option B (Incorrect):The transaction manager is a component of the database architecture but is not composed of the entire system (query processor, storage manager, etc.).

Option C (Correct):The transaction manager logs transactions like INSERT, UPDATE, and DELETE, ensuring consistency and recoverability.

Option D (Incorrect):Thestorage manageris responsible for translating queries into filesystem commands.

Adata typedefines the kind of data a column can store in a database. It ensures data consistency and efficient storage.

Option A (Correct):A data type is anamed set of values, such asINTEGER, VARCHAR, DATE, etc.

Option B (Incorrect):A tuple refers to arowin a relational database, not a data type.

Option C (Incorrect):Data typesdefinecolumn values, but they do not correspond directly to columns.

Option D (Incorrect):Data types do not have avaryingset of rows; they define attributes for columns.

In SQL,literalsrepresent explicit values such asnumbers, strings, or binary datadirectly written into queries. For example:

SELECT * FROM Employees WHERE Salary > 50000;

Here, 50000 is anumeric literal.

Option A (Correct):Literalsare explicit values used in SQL queries, such as 123, 'John Doe', and TRUE.

Option B (Incorrect):Commentsare non-executable text used for documentation within SQL code, typically denoted by -- or /* ... */.

Option C (Incorrect):Identifiersare names oftables, columns, or other database objects, such as EmployeeID.

Option D (Incorrect):Keywordsare reserved words in SQL (e.g., SELECT, FROM, WHERE) that define operations and syntax.

In aone-to-many (1:M) relationship, theforeign keyis placed in thetable on the "many" sideto establish the relationship with theprimary keyof the "one" side.

Example Usage:

A screenshot of a computer AI-generated content may be incorrect.

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)

);

Eachdepartmentcan havemany employees→ DeptID is aforeign keyin Employees.

Why Other Options Are Incorrect:

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

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

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

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

Indatabase modeling, the relationship between asupertype and its subtypesis called anIsA relationship.

Example Usage:

AVehicle supertypemay haveCar and Truck subtypes.

Vehicle

├── Car

├── Truck

InER 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 structurepreserves the IsA relationshipbetween Vehicle (supertype) and Car/Truck (subtypes).

Why Other Options Are Incorrect:

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

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

Option D (Weak entity) (Incorrect):Weak entitiesdepend on a strong entity, but supertype-subtype relations useinheritance(not dependency).

Thus, the correct answer isIsA relationship, as it describes theinheritance hierarchybetweensupertypes and subtypes.

When performing aJOIN operationin MySQL, the ON clause specifies thejoining condition, defining which columns from both tables should be matched.

Example:

sql

SELECT Employees.Name, Departments.DepartmentName

FROM Employees

JOIN Departments ON Employees.DepartmentID = Departments.ID;

Option A (Incorrect):AS is used foraliasing tables and columns, not for specifying join conditions.

Option B (Incorrect):JOIN defines the type of join (INNER JOIN, LEFT JOIN, etc.), butdoes not specify the columns.

Option C (Correct):The ON clause is used tospecify the join conditionbetween two tables.

Option D (Incorrect):AND is used in filtering conditions, not for joining tables.

When a VIEW is created in SQL, users mayinsert or updatedata through that view. However, if a row is inserted or updated in such a way that itviolates the conditionof the VIEW’s WHERE clause, it can lead to inconsistencies.

Topreventsuch unwanted modifications,SQL provides the WITH CHECK OPTION clause.

How WITH CHECK OPTION Works:

Ensures thatany 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 isrejected.

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);

Thisfailsbecause 30000 does not satisfy Salary > 50000.

Why Other Options Are Incorrect:

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

Option C (Incorrect):MATERIALIZED VIEW refers tostored viewsin some databases, but it doesnotreject incorrect inserts/updates.

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

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

Binary searchis an algorithm that finds a search value byrepeatedly dividing the search space into two halves. It is commonly used inindexed searches.

Example Usage in Databases:

B-Trees and B+ Trees(used in database indexing) applybinary searchto navigate the index efficiently.

If searching for ID = 50 in asorted 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):Readsevery row,much slowerthan binary search.

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

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

Thus, the correct answer isBinary search, as it repeatedlysplits the indexin two.

TheABS()function in SQL returns theabsolute valueof a given number, effectively measuring itsdistance from zero.

Example Usage:

sql

SELECT ABS(-50), ABS(50);

Result:

50 | 50

This function ensures that numbers arealways positive, regardless of their original sign.

Why Other Options Are Incorrect:

Option A (CONCAT) (Incorrect):Used tocombine strings(not numbers).

Option B (LOWER) (Incorrect):Converts text tolowercase, not numerical operations.

Option C (FROM) (Incorrect):Part of SELECT FROM queries,not a function.

Thus, the correct choice isABS(), which computes the absolute value of a number.

TheMERGEstatement, also known asUPSERT, combinesINSERT, UPDATE, and DELETEoperations into asingle statementbased on a given condition. It is commonly used indata warehouses and large-scale databases.

Example Usage:

sql

MERGE INTO Employees AS Target

USING NewEmployees AS Source

ON Target.ID = Source.ID

WHEN MATCHED THEN

UPDATE SET Target.Salary = Source.Salary

WHEN NOT MATCHED THEN

INSERT (ID, Name, Salary) VALUES (Source.ID, Source.Name, Source.Salary);

If a match is found, the UPDATE clause modifies the existing record.

If no match is found, the INSERT clause adds a new record.

Why Other Options Are Incorrect:

Option A (INTO) (Incorrect):Used in INSERT INTO, butdoes not combine operations.

Option B (JOIN) (Incorrect):Used to combine rows from multiple tables, butnot for merging data.

Option D (DROP) (Incorrect):Deletes database objects liketables, views, and indexes, butdoes not merge data.

Thus, the correct answer isMERGE, as itcombines inserts, updates, and deletes into a single operation.

Thecorrect syntaxfor deleting records from a table in SQL is:

sql

DELETE FROM table_name WHERE condition;

This deletesonly the rowsthat match the condition.

Example Usage:

sql

DELETE FROM Employees WHERE Salary < 30000;

Deletesall employees earning less than $30,000.

Why Other Options Are Incorrect:

Option A (Incorrect):Missing FROMkeyword. The correct syntax is DELETE FROM table_name.

Option C (Partially Correct):DELETE FROM table_name;deletes all rows, but it lacks a WHERE clause.

Option D (Incorrect):DELETE *is not validin SQL. The correct command is just DELETE FROM.

Thus, the correct answer isDELETE FROM table_name WHERE condition;.

Thesecond step in implementing relationshipsis definingone-to-one (1:1) relationshipsbetween 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, eachemployee has exactly one detail record, creating a1:1 relationship.

Why Other Options Are Incorrect:

Option A (Implement weak entities) (Incorrect):Weak entities rely on aforeign keyand are implementedlater.

Option C (Implement subtype entities) (Incorrect):Subtypes arespecial casesandnot implemented in the second step.

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

Thus, the correct answer isImplement one-one relationships, as it is thenext logical stepafter defining entities.

MongoDB is aNoSQL (non-relational) databasethat isopen-sourceand supportsdocument-oriented storage. It allows for flexible schema design and is optimized for big data applications.

Option A (Correct):MongoDB is aNoSQL databasewith an open-sourceAGPLlicense, making it both free to use and non-relational.

Option B (Incorrect):SQL Serveris arelational database(RDBMS) developed by Microsoft and isnot open-source.

Option C (Incorrect):MySQLisopen-sourcebut is arelational database(RDBMS), not a NoSQL system.

Option D (Incorrect):Oracle Databaseisrelationalandproprietary(not open-source).

Thefirst stepin database analysis isidentifying entities, which are thereal-world objectsthat need to be represented in the database.

Example Usage:

In a school system, the mainentitiescould be:

Students, Courses, Instructors

Why Other Options Are Incorrect:

Option A (Determine cardinality) (Incorrect):Determining relationships comesafteridentifying entities.

Option C (Draw an ER diagram) (Incorrect):ER diagramsvisualizeentities but arenot the first step.

Option D (Implement attributes) (Incorrect):Attributes aredefined afterentities are identified.

Thus, the correct answer isIdentify entities, asentities form the foundation of the databasemodel.

Cardinalitydefines theminimum and maximum number of occurrencesof one entity in relation to another.

Example Usage in an ER Model:

One-to-Many (1:M): Acustomer can place multiple orders, but each order belongs to onlyonecustomer.

Customers (1) ——— (M) Orders

Cardinality notation:

(1,1) → One-to-One

(0,M) → Zero-to-Many

(1,M) → One-to-Many

Why Other Options Are Incorrect:

Option B (Physical design) (Incorrect):Focuses onstorage and indexing, not relationships.

Option C (Attribute minimum) (Incorrect):No such formal term in database modeling.

Option D (Partition) (Incorrect):Refers todividing tables, not relationship constraints.

Thus, the correct answer isCardinality, as it definesmin/max constraints on relationships.