Get the Preplance app for a seamless learning experience. Practice offline, get daily streaks, and stay ahead with real-time interview updates.
Get it on
Google Play
4.9/5 Rating on Store
SQL & Databases · Question Set
SQL Core Fundamentals interview questions for placements and exams.
Questions
14
Included in this set
Subject
SQL & Databases
Explore more sets
Difficulty
Mixed
Level of this set
Go through each question and its explanation. Use this set as a focused practice pack for SQL & Databases.
INSERT adds new rows. List columns in a stable order to avoid surprises when schema evolves. Bulk loads and multi-row inserts are faster than many single-row inserts for large data.
INSERT INTO employees (id, name, email) VALUES (101, 'Asha', 'asha@example.com');
For complete preparation, combine this set with full subject-wise practice for SQL & Databases. You can also explore other subjects and sets from the links below.
Preview the effect with a SELECT using the same predicate. Then run the UPDATE or DELETE. Consider transactions and backups when touching many rows. Cascades may propagate changes across tables.
-- preview SELECT * FROM orders WHERE status='CANCELLED'; -- then DELETE FROM orders WHERE status='CANCELLED';
SELECT star pulls every column, even those you do not need. That increases I O, network transfer, and CPU, and can hide poor indexing because wider rows change access paths. Listing columns makes intent clear, stabilizes APIs, and reduces breakage when new columns are added. It also helps the optimizer when covering indexes can satisfy the query without touching the base table.
SELECT id, name, status FROM tickets WHERE status='OPEN';
NULL means unknown. Comparisons like col = NULL are unknown, so conditions fail. Use IS NULL and IS NOT NULL. Sort order places NULLs either first or last depending on the engine or explicit NULLS FIRST or LAST. Aggregates skip NULLs except COUNT(*). Use COALESCE to substitute defaults, and design constraints to avoid surprise NULLs where business rules require values.
SELECT COALESCE(phone,'N/A') AS phone FROM users ORDER BY phone NULLS LAST;
Percent matches any sequence of characters, including empty. Underscore matches exactly one character. Anchoring at the end, like 'abc%', can use indexes; leading wildcards like '%abc' usually force scans. Use LIKE for simple patterns. For heavy text search or complex rules, prefer full text indexes or regex features to keep queries fast and precise.
SELECT * FROM students WHERE first_name LIKE 'K%'; SELECT * FROM students WHERE first_name LIKE '__K%';
NULL represents unknown. Comparisons with equals return unknown, not true. Use IS NULL or IS NOT NULL. When aggregating, functions like COUNT(col) skip NULLs, while COUNT(*) counts all rows.
SELECT COUNT(*) total, COUNT(email) with_email FROM users WHERE deleted_at IS NULL;
ORDER BY sorts ascending by default. Use DESC for reverse order. Without ORDER BY, row order is not guaranteed, even if it looks stable in small tests.
SELECT name FROM customers ORDER BY name;
LIMIT n OFFSET m returns a window of rows. It is simple and widely supported. For large pages, prefer keyset pagination using a stable sort key to avoid deep offsets and performance drops.
SELECT id, name FROM products ORDER BY id LIMIT 20 OFFSET 40;
Aliases are temporary names for columns or tables in a single query. They improve readability and help when the same table is referenced twice. They do not change schema or metadata; they exist only during the statement.
SELECT e.id AS emp_id, d.name AS dept FROM employees e JOIN departments d ON d.id = e.dept_id;
WHERE applies to raw rows, before grouping. It reduces input early and improves performance when selective. Use HAVING after GROUP BY when you need to filter on aggregate results, like COUNT or SUM.
SELECT department_id, COUNT(*) FROM employees WHERE active = 1 GROUP BY department_id;
SELECT chooses columns and rows from one or more tables. The star is a shorthand for all columns. In production, prefer listing columns to control payloads, avoid hidden schema breaks, and help indexes get used effectively.
SELECT * FROM employees;
IN tests membership in a list. It is clear for short, explicit sets. BETWEEN is for ranges, and LIKE is for pattern matching. Use the right tool for the comparison you need.
SELECT * FROM stores WHERE city IN ('Delhi','Mumbai');Pick types that reflect domain rules and size. Use integers for ids, proper date or timestamp types for time, and numeric with scale for money. Narrow types reduce storage, improve cache usage, and speed scans and joins. Consistent types across join keys prevent implicit casts that block index use. Document units and time zones to avoid logic bugs later.
CREATE TABLE payments( id BIGINT PRIMARY KEY, amount NUMERIC(12,2) NOT NULL, paid_at TIMESTAMP NOT NULL );
Wrap the steps in a transaction so all succeed or all roll back. Insert the detail row, update the aggregate with a precise predicate, then select the final state to confirm. Keep the transaction short to reduce lock time. Check for errors at each step and commit only when all statements succeed. This preserves consistency under concurrent load.
BEGIN; INSERT INTO orders(id, customer_id, total) VALUES(?, ?, ?); UPDATE customers SET order_count = order_count + 1 WHERE id = ?; SELECT order_count FROM customers WHERE id = ?; COMMIT;