Here are one-liner example queries for each point:
1. **`SELECT`**:
```sql
SELECT name FROM employee;
```
2. **`SELECT ALL`**:
```sql
SELECT * FROM employee;
```
3. **`WHERE`**:
```sql
SELECT name FROM employee WHERE salary > 50000;
```
4. **`DISTINCT`**:
```sql
SELECT DISTINCT department FROM employee;
```
5. **`ORDER BY`**:
```sql
SELECT name, salary FROM employee ORDER BY salary DESC;
```
6. **`AND`**:
```sql
SELECT name FROM employee WHERE department = 'HR' AND salary > 40000;
```
7. **`OR`**:
```sql
SELECT name FROM employee WHERE department = 'HR' OR salary > 40000;
```
8. **`NOT`**:
```sql
SELECT name FROM employee WHERE NOT department = 'HR';
```
9. **`INSERT INTO` multiple values**:
```sql
INSERT INTO employee (name, department, salary) VALUES ('John', 'IT',
50000), ('Jane', 'HR', 60000);
```
10. **`IS NULL`**:
```sql
SELECT name FROM employee WHERE manager_id IS NULL;
```
11. **`MIN`**:
```sql
SELECT MIN(salary) AS MinSalary FROM employee;
```
12. **`IN`**:
```sql
SELECT name FROM employee WHERE department IN ('HR', 'IT', 'Finance');
```
13. **`BETWEEN`**:
```sql
SELECT name FROM employee WHERE salary BETWEEN 30000 AND 60000;
```
14. **`GROUP BY`**:
```sql
SELECT department, COUNT(*) AS TotalEmployees FROM employee GROUP BY
department;
```
15. **`HAVING`**:
```sql
SELECT department, AVG(salary) AS AvgSalary FROM employee GROUP BY
department HAVING AVG(salary) > 50000;
```
16. **`CREATE TABLE`**:
```sql
CREATE TABLE employee (id INT PRIMARY KEY, name VARCHAR(50), salary
INT);
```
17. **`ALTER TABLE ADD COLUMN`**:
```sql
ALTER TABLE employee ADD COLUMN age INT;
```
18. **`DELETE COLUMN`** (not directly supported in all databases; use drop
column):
```sql
ALTER TABLE employee DROP COLUMN age;
```
19. **`UPDATE SET`**:
```sql
UPDATE employee SET salary = salary + 5000 WHERE department = 'HR';
```
20. **`LIKE` (start, end, contain)**:
- **Starts with**:
```sql
SELECT name FROM employee WHERE name LIKE 'J%';
```
- **Ends with**:
```sql
SELECT name FROM employee WHERE name LIKE '%n';
```
- **Contains**:
```sql
SELECT name FROM employee WHERE name LIKE '%an%';
```
#1. Write an SQL query to retrieve the second highest salary from the employee
table.
SELECT MAX(salary) AS SecondHighestSalary
FROM employee
WHERE salary < (SELECT MAX(salary) FROM employee);
- Explanation:
- The subquery finds the highest salary.
- The outer query finds the maximum salary below the highest salary.
SELECT DISTINCT salary AS SecondHighestSalary
FROM employee
ORDER BY salary DESC
LIMIT 1 OFFSET 1;
#### **2. Explain the difference between INNER JOIN and LEFT JOIN.**
- **INNER JOIN**:
- Returns only rows where there is a match in both tables.
- Example:
SELECT *
FROM table1
INNER JOIN table2
ON table1.id = table2.id;
```
- **LEFT JOIN**:
- Returns all rows from the left table and the matched rows from the right
table. If no match exists, NULL values are returned for the right table's columns.
- Example:
```sql
SELECT *
FROM table1
LEFT JOIN table2
ON table1.id = table2.id;
```
#### **3. How do you optimize a SQL query?**
- Use indexing for frequently queried columns.
- Minimize the use of `SELECT *` by specifying required columns.
- Avoid using subqueries if a JOIN can be used.
- Optimize `WHERE` clauses by filtering rows efficiently.
- Use proper database normalization.
- Analyze query execution plans to identify bottlenecks.
- Avoid unnecessary joins and DISTINCT if not required.
---
#### **4. What is the difference between the DROP and TRUNCATE
commands?**
- **DROP**:
- Deletes the entire table and its structure from the database.
- Cannot be rolled back.
- Example:
```sql
DROP TABLE table_name;
```
- **TRUNCATE**:
- Deletes all rows from the table but keeps its structure intact.
- Cannot be rolled back in most systems.
- Example:
```sql
TRUNCATE TABLE table_name;
#### **5. How would you add a new column to an existing table? What if you
want to set a default value?**
- Add a new column:
```sql
ALTER TABLE table_name
ADD column_name datatype;
```
- Add a new column with a default value:
```sql
ALTER TABLE table_name
ADD column_name datatype DEFAULT default_value;
#### **6. How do you insert multiple rows into a table in a single query?**
```sql
INSERT INTO table_name (column1, column2)
VALUES (value1a, value2a), (value1b, value2b), (value1c, value2c);
#### **7. What is the importance of ACID properties in transactions?**
- **Atomicity**: Ensures all operations in a transaction are completed;
otherwise, none are applied.
- **Consistency**: Ensures the database remains in a consistent state before
and after a transaction.
- **Isolation**: Ensures transactions are processed independently without
interference.
- **Durability**: Guarantees that committed transactions are saved
permanently.
#### **8. What is the difference between the IN and EXISTS operators?**
- **IN**:
- Checks if a value exists in a specified set of values or subquery result.
- Example:
```sql
SELECT *
FROM employee
WHERE department_id IN (1, 2, 3);
```
- **EXISTS**:
- Checks if a subquery returns any rows.
- Example:
```sql
SELECT *
FROM employee e
WHERE EXISTS (
SELECT 1
FROM department d
WHERE d.id = e.department_id
);
#### **9. What is the difference between scalar and aggregate functions in
SQL?**
- **Scalar Functions**:
- Operate on a single value and return a single value.
- Example: `UPPER(column_name)`, `ROUND(value)`.
- Usage:
```sql
SELECT UPPER(name) AS UpperCaseName FROM employee;
```
- **Aggregate Functions**:
- Operate on multiple values and return a single aggregated value.
- Example: `SUM(column_name)`, `AVG(column_name)`.
- Usage:
```sql
SELECT AVG(salary) AS AverageSalary FROM employee;
```
#### **10. How do you perform string concatenation in MySQL?**
- Use the `CONCAT` function:
```sql
SELECT CONCAT(first_name, ' ', last_name) AS FullName FROM employee;
#### **11. What is the LIMIT clause used for in SQL queries? Provide an
example.**
- **LIMIT**: Restricts the number of rows returned by a query.
- Example:
```sql
SELECT *
FROM employee
ORDER BY salary DESC
LIMIT 5;
```
- Retrieves the top 5 highest-paid employees.
#### **12. What is a SELF JOIN and when would you use it?**
- A **SELF JOIN** is a join where a table is joined with itself.
- Use it to compare rows within the same table.
- Example:
```sql
SELECT e1.name AS Employee1, e2.name AS Employee2
FROM employee e1, employee e2
WHERE e1.manager_id = e2.id;
```
- Retrieves employees and their managers from the same table.
#### **13. What is the difference between JOIN and UNION?**
- **JOIN**:
- Combines rows from two or more tables based on related columns.
- Example:
```sql
SELECT e.name, d.department_name
FROM employee e
JOIN department d
ON e.department_id = d.id;
```
- **UNION**:
- Combines results of two or more `SELECT` queries into a single result set and
removes duplicates by default.
- Example:
SELECT name FROM employee
UNION
SELECT name FROM manager;
### **14. What is the use of indexes in SQL, and how do they improve query
performance?**
Indexes are used to speed up the retrieval of data from a database. They allow
the database to quickly locate the rows that satisfy a query condition without
scanning the entire table. Indexes improve performance in queries with
`WHERE`, `JOIN`, and `ORDER BY` clauses by reducing the number of rows the
database engine needs to process.
---
### **15. How would you retrieve the top N rows in SQL?**
To retrieve the top N rows, you can use the `LIMIT` clause (in MySQL or
PostgreSQL) or the `TOP` keyword (in SQL Server). These limit the number of
rows returned by a query. In Oracle, you can use `ROWNUM` or `FETCH FIRST N
ROWS ONLY`.
---
### **16. Explain the concept of normalization and its advantages.**
Normalization is the process of organizing database tables to reduce redundancy
and improve data integrity. It involves dividing data into smaller, related tables
and applying rules like 1NF, 2NF, and 3NF.
Advantages include reduced data duplication, improved consistency, better
query performance, and easier database maintenance.
---
### **17. What is a primary key, and why is it important?**
A primary key is a column (or combination of columns) that uniquely identifies
each row in a table. It ensures there are no duplicate or null values. Primary keys
are essential for maintaining data integrity and creating relationships between
tables.
---
### **18. What is a foreign key, and how does it maintain referential
integrity?**
A foreign key is a column in one table that refers to the primary key in another
table. It maintains referential integrity by ensuring that a value in the foreign
key column matches an existing value in the referenced primary key, thereby
maintaining valid relationships between tables.
---
### **19. What is the difference between GROUP BY and ORDER BY?**
`GROUP BY` is used to group rows with the same values into summary rows,
often with aggregate functions like `SUM` or `COUNT`.
`ORDER BY` is used to sort the rows of a query result in ascending or descending
order.
---
### **20. What is the difference between HAVING and WHERE clauses in
SQL?**
The `WHERE` clause filters rows before any grouping is applied. It is used for
individual rows.
The `HAVING` clause filters groups after they have been created by the `GROUP
BY` clause. It is often used with aggregate functions.
### **1. What is a View?**
A **view** is a virtual table in SQL that is based on a SELECT query. It doesn’t
store data itself but provides a way to simplify complex queries and reuse them.
- **Example**:
```sql
CREATE VIEW EmployeeSalary AS
SELECT name, salary FROM employee WHERE salary > 50000;
```
---
### **2. What is a Stored Procedure?**
A **stored procedure** is a precompiled set of SQL statements that can be
executed as a single unit. It allows reusable and modular SQL logic.
- **Example**:
```sql
CREATE PROCEDURE IncreaseSalary(IN percentage INT)
BEGIN
UPDATE employee SET salary = salary + (salary * percentage / 100);
END;
```
---
### **3. What is a Trigger?**
A **trigger** is a special type of stored procedure that automatically executes
in response to certain events (INSERT, UPDATE, DELETE) on a table.
- **Example**:
```sql
CREATE TRIGGER BeforeInsertTrigger
BEFORE INSERT ON employee
FOR EACH ROW
SET NEW.salary = IF(NEW.salary < 30000, 30000, NEW.salary);
```
---
### **4. What is Normalization and its Types?**
**Normalization** is the process of structuring a database to reduce
redundancy and dependency by dividing data into smaller related tables.
- **Types of Normalization**:
1. **First Normal Form (1NF)**: Ensures that all columns have atomic values
(no repeating groups or arrays).
2. **Second Normal Form (2NF)**: Ensures all non-primary key attributes are
fully functionally dependent on the primary key.
3. **Third Normal Form (3NF)**: Ensures no transitive dependencies (non-
primary attributes depend only on the primary key).
4. **Boyce-Codd Normal Form (BCNF)**: Ensures stricter conditions than 3NF
for functional dependency.
---
### **5. What is a Database?**
A **database** is an organized collection of data that can be easily accessed,
managed, and updated. It is stored and managed by a database management
system (DBMS).
- Examples: MySQL, PostgreSQL, Oracle.
---
### **6. What is a Schema?**
A **schema** is the structure of a database that defines how data is organized,
including tables, views, indexes, procedures, and relationships. It serves as a
blueprint for the database.
- Example: A database can have a schema defining tables like `employee` and
`department`.
---
### **7. What are Constraints in SQL?**
**Constraints** are rules enforced on columns in a table to ensure the integrity
and accuracy of the data.
- **Types of Constraints**:
1. **PRIMARY KEY**: Ensures unique and non-null values for the column.
2. **FOREIGN KEY**: Ensures referential integrity between two tables.
3. **UNIQUE**: Ensures all values in a column are unique.
4. **NOT NULL**: Ensures the column cannot contain null values.
5. **CHECK**: Ensures values satisfy a specified condition.
6. **DEFAULT**: Assigns a default value to the column if no value is provided.
- **Example**:
```sql
CREATE TABLE employee (
id INT PRIMARY KEY,
name VARCHAR(50) NOT NULL,
salary INT CHECK (salary > 0),
department_id INT,
FOREIGN KEY (department_id) REFERENCES department(id)
);
```
