Data-Management-Foundations Exam Dumps and Practice Questions

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.

An attribute type refers to a single, specific value within a table, such as Salary, Age, or Price.

Example Usage:

CREATE TABLE Employees (

EmpID INT PRIMARY KEY,

Name VARCHAR(50),

Salary DECIMAL(10,2)

);

Salary is an attribute type with individual values for each employee.

Why Other Options Are Incorrect:

Option A (Glossary) (Incorrect): Refers to documentation, not database values.

Option B (Entity type) (Incorrect): Represents a class of objects (e.g., Employees), not individual values.

Option D (Relationship) (Incorrect): Defines connections between entities, not attributes.

Thus, the correct answer is Attribute type, as it represents an individual data value.

The CHECK constraint is used in SQL to enforce rules on a column's values. It ensures that data inserted into a table meets specified conditions, such as range restrictions or logical rules.

Example Usage:

sql

CREATE TABLE Employees (

ID INT PRIMARY KEY,

Name VARCHAR(50),

Salary INT CHECK (Salary BETWEEN 30000 AND 150000)

);

This constraint ensures that salary values fall between 30,000 and 150,000.

If an INSERT or UPDATE statement tries to set Salary = 20000, it fails because it does not meet the CHECK condition.

Why Other Options Are Incorrect:

Option B (FROM) (Incorrect): Used in SELECT statements, not for constraints.

Option C (WHERE) (Incorrect): Filters rows in queries but does not enforce constraints.

Option D (SET) (Incorrect): Used for updating records (UPDATE table_name SET column = value) but not for defining constraints.

Thus, CHECK is the correct answer, as it ensures that column values remain within an expected range.

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.

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.