Data and Database Fundamentals practice questions

Simpler to set up and manage

Why wrong: While flat file systems can be set up with minimal overhead, they lack the relational integrity and concurrent-access controls that a database management system provides. This option is tempting because for a small, single-user list of records, a flat file is indeed quick to configure. However, in a scenario requiring simultaneous multi-user updates and enforced data consistency across customer records, the absence of transaction management and referential constraints makes a flat file system unsuitable.

Stores data in a non-structured format

Why wrong: Databases store data in structured formats; flat files can be unstructured.

No need for a query language

Why wrong: Databases use query languages like SQL, which is a feature, not a disadvantage.

Referential integrity

Why wrong: Referential integrity ensures foreign key relationships are valid.

Input validation

Why wrong: Input validation is a front-end check, not a database integrity concept.

Domain integrity

Why wrong: Domain integrity ensures column values conform to data types and constraints.

Entity integrity

Why wrong: Entity integrity is enforced by primary keys, not foreign keys.

Normalization

Why wrong: Normalization reduces redundancy, not directly enforced by foreign keys.

Domain integrity

Why wrong: Domain integrity is about allowed values for a column.

Wide-column store

Why wrong: Wide-column stores like Cassandra use column families.

Graph database

Why wrong: Graph databases like Neo4j focus on relationships between entities.

Key-value store

Why wrong: Key-value stores like Redis store simple key-value pairs.

RETRIEVE * FROM Customers WHERE city = 'London';

Why wrong: RETRIEVE is not SQL; the correct keyword is SELECT.

SELECT * FROM Customers HAVING city = 'London';

Why wrong: HAVING is used with GROUP BY, not for filtering rows.

GET * FROM Customers WHERE city = 'London';

Why wrong: GET is not a valid SQL command.

Denormalization

Why wrong: Denormalization adds redundancy for performance.

Indexing

Why wrong: Indexing improves query performance, not redundancy.

Partitioning

Why wrong: Partitioning splits data for manageability, not necessarily to reduce redundancy.

MySQL

Why wrong: MySQL is open-source (though Oracle owns it, it's still available under open-source license).

PostgreSQL

Why wrong: PostgreSQL is open-source.

SQLite

Why wrong: SQLite is open-source.

Platform as a Service (PaaS)

Why wrong: PaaS provides a platform for applications, but DBaaS is a specific type of PaaS for databases.

Software as a Service (SaaS)

Why wrong: SaaS delivers applications over the internet, not databases.

Infrastructure as a Service (IaaS)

Why wrong: IaaS provides virtual machines, not managed databases.

ADD

Why wrong: ADD is not a standard SQL DML command.

CREATE

Why wrong: CREATE is used to create tables or databases.

UPDATE

Why wrong: UPDATE modifies existing records.

Self-referencing

Why wrong: Self-referencing uses a foreign key to the same table.

One-to-one

Why wrong: One-to-one can be implemented with a single foreign key.

One-to-many

Why wrong: One-to-many uses a foreign key in the 'many' table.

SELECT Name, CourseID FROM Students RIGHT JOIN Enrollments ON Students.StudentID = Enrollments.StudentID;

Why wrong: RIGHT JOIN returns all rows from the right table (Enrollments) and matching rows from Students. Students without enrollments are excluded, but enrollments without a matching student (if any) would appear with NULL for Name. This does not match the requirement to list each student's enrolled courses.

SELECT Name, CourseID FROM Students, Enrollments WHERE Students.StudentID = Enrollments.StudentID;

Why wrong: The implicit comma join without a WHERE clause produces a Cartesian product (each row of Students paired with each row of Enrollments). Although the WHERE clause here is present, the syntax is outdated and less clear; it functions as an INNER JOIN, but the query is correct. However, it is not the best practice; optionally, it is acceptable but not the only correct syntax.

SELECT Name, CourseID FROM Students LEFT JOIN Enrollments ON Students.StudentID = Enrollments.StudentID;

Why wrong: LEFT JOIN returns all students, even those without enrollments, who would show NULL for CourseID. This does not meet the requirement to list only students with enrolled courses.

Requires normalized data

Why wrong: Normalization is a relational concept; NoSQL often denormalizes.

Enforces strict schema definition

Why wrong: Relational databases enforce strict schema; NoSQL is schema-flexible.

Uses SQL for queries

Why wrong: Many NoSQL databases use their own query languages.

SQLite

Why wrong: SQLite is an embedded database, not a cloud service.

Microsoft SQL Server Express

Why wrong: This is a free local edition, not cloud-based.

MySQL Community Edition

Why wrong: This is on-premise open-source software, not a cloud service.

The primary key of Professors is CourseID.

Why wrong: Primary key of Professors is ProfessorID, not CourseID.

The relationship between Professors and Courses is many-to-many.

Why wrong: It is one-to-many because one professor can teach many courses, but a course has one professor.

Spreadsheet

Why wrong: Spreadsheets are not databases.

Relational database

Why wrong: Relational databases are SQL-based, not NoSQL.

Flat file

Why wrong: Flat files are not NoSQL databases.

Constraint

Why wrong: A constraint enforces rules but does not specifically provide unique identification.

Index

Why wrong: An index speeds up queries but does not enforce uniqueness by default.

Foreign key

Why wrong: A foreign key references a primary key in another table and does not uniquely identify rows.

Denormalization

Why wrong: Denormalization adds redundancy to improve read performance.

Encryption

Why wrong: Encryption secures data but does not reduce redundancy.

Indexing

Why wrong: Indexing improves query performance but does not reduce redundancy.

Software as a Service (SaaS)

Why wrong: SaaS provides applications, not databases.

Infrastructure as a Service (IaaS)

Why wrong: IaaS provides virtual machines, but the customer manages the database software.

Platform as a Service (PaaS)

Why wrong: PaaS provides a runtime environment and middleware for deploying custom applications, but the startup’s requirement is specifically to avoid hardware maintenance and gain automatic scaling of the *database* itself. That need is met by Database as a Service (DBaaS), which abstracts the database engine and storage layer. PaaS is tempting because it also abstracts infrastructure, but it would still require the startup to manage the database software and scaling logic manually. PaaS would be correct if the startup needed to deploy a custom web application without managing the underlying OS and runtime.

GET name, price FROM Products WHERE price > 50;

Why wrong: GET is not a valid SQL keyword.

SELECT name, price FROM Products;

Why wrong: This retrieves all rows without the price condition.

SELECT * FROM Products WHERE price > 50;

Why wrong: This retrieves all columns, not just name and price.

It stores data in tables with rows and columns.

Why wrong: That describes relational databases.

It uses SQL for querying.

Why wrong: NoSQL databases typically use their own query languages.

It enforces strict referential integrity.

Why wrong: NoSQL databases often relax such constraints.