Tajamul Khan
@Tajamulkhann
CREATE TABLE: Creates a new table.
CREATE TABLE table_name (id INT PRIMARY KEY,
name VARCHAR(50));
ALTER TABLE: Modifies an existing table.
ALTER TABLE table_name ADD column2 INT;
DROP TABLE: Deletes a table.
DROP TABLE table_name;
CREATE INDEX: Creates an index on a table.
CREATE INDEX idx_name ON table_name (column1);
DROP INDEX: Removes an index.
DROP INDEX idx_name ON table_name;
CREATE VIEW: Creates virtual table based on query.
CREATE VIEW view_name AS SELECT column1,
column2 FROM table_name;
DROP VIEW: Deletes a view.
DROP VIEW view_name;
RENAME TABLE: Renames an existing table.
RENAME TABLE old_table_nm TO new_table_name;
@Tajamulkhann
SELECT: Retrieves specific columns from a table.
SELECT column1, column2 FROM table_name;
DISTINCT: Removes duplicate rows from the result.
SELECT DISTINCT column1 FROM table_name;
WHERE: Filters rows based on a condition.
SELECT * FROM table_name WHERE column1 = 'v1';
ORDER BY: Sorts result set by one or more columns.
SELECT * FROM table_nm ORDER BY column1 ASC;
LIMIT / FETCH: Limits the number of rows returned.
SELECT * FROM table_name LIMIT 10;
LIKE: Searches for patterns in text columns.
SELECT * FROM table_name WHERE col1 LIKE 'A%';
IN: Filters rows with specific values.
SELECT * FROM table_nm WHERE col1 IN ('v1', 'v2');
BETWEEN: Filters rows within a range of values.
SELECT * FROM table WHERE c1 BETWEEN 1 AND 20;
@Tajamulkhann
COUNT(): Returns the number of rows.
SELECT COUNT(*) FROM table_name;
SUM(): Calculates the sum of a numeric column.
SELECT SUM(column1) FROM table_name;
AVG(): Calculates the average of a numeric column.
SELECT AVG(column1) FROM table_name;
MIN(): Returns the smallest value in a column.
SELECT MIN(column1) FROM table_name;
MAX(): Returns the largest value in a column.
SELECT MAX(column1) FROM table_name;
GROUP BY: Groups rows for aggregation.
SELECT col1, COUNT(*) FROM t1 GROUP BY col1;
HAVING: Filters grouped rows based on a condition.
SELECT column1, COUNT(*) FROM t1 GROUP BY
column1 HAVING COUNT(*) > 5;
DISTINCT COUNT(): Counts unique values in column.
SELECT COUNT(DISTINCT col1) FROM table_name;
@Tajamulkhann
INSERT INTO: Adds new rows to a table.
INSERT INTO table_name (column1, column2)
VALUES ('value1', 'value2');
UPDATE: Updates existing rows in a table.
UPDATE table_name SET col1 = 'value' WHERE id = 1;
DELETE: Removes rows from a table.
DELETE FROM table_name WHERE column1 = 'value';
MERGE: Combines INSERT, UPDATE, and DELETE
based on a condition.
MERGE INTO table_name USING source_table ON
condition WHEN MATCHED THEN UPDATE SET
column1 = value WHEN NOT MATCHED THEN INSERT
(columns) VALUES (values);
TRUNCATE: Removes all rows from a table without
logging.
TRUNCATE TABLE table_name;
REPLACE: Deletes existing rows and inserts new rows
(MySQL-specific).
REPLACE INTO table_name VALUES (value1, value2);
@Tajamulkhann
Commit Transaction: Finalizes changes when all
operations succeed.
START TRANSACTION;
UPDATE accounts SET balance = 1000 WHERE id = 1;
WHERE id = 2; COMMIT;
Execute a Stored Procedure: Undoes changes if an
error occurs or the transaction is not committed.
START TRANSACTION;
UPDATE accounts SET balance = 1000 WHERE id = 1;
ROLLBACK;
Using Savepoints: Set a rollback point within a
transaction, allowing partial rollback without
affecting the whole transaction.
START TRANSACTION;
UPDATE accounts SET balance = 1000 WHERE id = 1;
SAVEPOINT sp1;
UPDATE accounts SET balance = 2000 WHERE id = 3;
-- Simulate failure
ROLLBACK TO SAVEPOINT sp1;
UPDATE accounts SET balance = 1000 WHERE id = 2;
COMMIT;
@Tajamulkhann
UNION: Combines results from two queries,
removing duplicates.
SELECT column1 FROM table1 UNION SELECT
column1 FROM table2;
UNION ALL: Combines results from two queries,
including duplicates.
SELECT column1 FROM table1 UNION ALLSELECT
column1 FROM table2;
INTERSECT: Returns common rows from both
queries.
SELECT column1 FROM table1 INTERSECT SELECT
column1 FROM table2;
EXCEPT (or MINUS): Returns rows from the first
query that are not in the second query.
SELECT column1 FROM table1 EXCEPTSELECT
column1 FROM table2;
@Tajamulkhann
INNER JOIN: matching values in both tables.
SELECT * FROM table1 INNER JOIN table2 ON
table1.id = table2.id;
LEFT JOIN: Returns all rows from the left table and
matching rows from the right table.
SELECT * FROM table1 LEFT JOIN table2 ON table1.id
= table2.id;
RIGHT JOIN: Returns all rows from the right table and
matching rows from the left table.
SELECT * FROM table1 RIGHT JOIN table2 ON
table1.id = table2.id;
FULL OUTER JOIN: Returns rows when there is a
match in either table.
SELECT * FROM table1 FULL OUTER JOIN table2 ON
table1.id = table2.id;
CROSS JOIN: Cartesian product of both tables.
SELECT * FROM table1 CROSS JOIN table2;
SELF JOIN: Joins a table with itself.
SELECT a.column1, b.column1 FROM table_name a,
table_name b WHERE a.id = b.parent_id;
@Tajamulkhann
CONCAT(): Concatenates strings.
SELECT CONCAT(first_name, ' ', last_name) FROM
table_name;
SUBSTRING(): Extracts a substring from a string.
SELECT SUBSTRING(column1, 1, 5) FROM table_nm;
LENGTH(): Returns the length of a string.
SELECT LENGTH(column1) FROM table_name;
ROUND(): Rounds a number to a specified number of
decimal places.
SELECT ROUND(column1, 2) FROM table_name;
NOW(): Returns the current timestamp.
SELECT NOW();
DATE_ADD(): Adds a time interval to a date.
SELECT DATE_ADD(NOW(), INTERVAL 7 DAY);
COALESCE(): Returns the first non-null value.
SELECT COALESCE(column1, column2) FROM
table_name;
IFNULL(): Replaces NULL values with desired value.
SELECT IFNULL(col1, 'default') FROM table_name;
@Tajamulkhann
ROW_NUMBER: Assigns a unique number to each row
in a result set.
SELECT ROW_NUMBER() OVER (PARTITION BY
department ORDER BY salary DESC) AS row_num
FROM employees;
RANK: Assigns a rank to each row, with gaps for ties.
SELECT RANK() OVER (PARTITION BY department
ORDER BY salary DESC) AS rank FROM employees;
DENSE_RANK: Assigns a rank to each row without
gaps for ties.
SELECT DENSE_RANK() OVER (PARTITION BY
department ORDER BY salary DESC) AS dense_rank
FROM employees;
NTILE: Divides rows into equal parts.
SELECT NTILE(4) OVER (ORDER BY salary) AS
quartile FROM employees;
LEAD(): Accesses subsequent rows’ data.
SELECT name, salary, LEAD(salary) OVER (ORDER BY
salary) AS next_salary FROM employees;
LAG(): Accesses subsequent rows’ data.
SELECT name, salary, LAG(salary) OVER (ORDER BY
salary) AS previous_salary FROM employees;
@Tajamulkhann
Create a Stored Procedure:
CREATE PROCEDURE sp_GetEmployeeByID
@EmployeeID INT
AS
BEGIN
-- SQL statements inside the stored procedure
SELECT * FROM Employees
WHERE EmployeeID = @EmployeeID;
Execute a Stored Procedure:
EXEC sp_GetEmployeeByID @EmployeeID = 1;
Stored Procedure with OUT Parameter:
CREATE PROCEDURE GetEmployeeCount (OUT
emp_count INT) BEGINSELECT COUNT(*) INTO
emp_count FROM employees; END;
Drop a Stored Procedure:
DROP PROCEDURE GetEmployeeDetails;
@Tajamulkhann
Create a Trigger (Before Insert):
CREATE TRIGGER set_created_at
BEFORE INSERT ON employees
FOR EACH ROW
SET NEW.created_at = NOW();
After Update Trigger:
CREATE TRIGGER log_updates
AFTER UPDATE ON employees
FOR EACH ROW
INSERT INTO audit_log(emp_id, old_salary,
new_salary, updated_at)
VALUES (OLD.id, OLD.salary, NEW.salary, NOW());
After Delete Trigger:
CREATE TRIGGER log_deletes
AFTER DELETE ON employees
FOR EACH ROW
INSERT INTO audit_log(emp_id, old_salary,
new_salary, deleted_at)
VALUES (OLD.id, OLD.salary, NULL, NOW());
@Tajamulkhann
Scalar Subquery: Returns a single value.
SELECT name, salary
FROM employees
WHERE salary > (SELECT AVG(salary) FROM
employees);
Correlated Subquery:
SELECT e1.name, e1.salary
FROM employees e1
WHERE e1.salary > (SELECT AVG(e2.salary) FROM
employees e2 WHERE e1.department =
e2.department);
@Tajamulkhann
With a Single CTE:
WITH DepartmentSalary AS (
SELECT department, AVG(salary) AS avg_salary
FROM employees
GROUP BY department
)
SELECT *
FROM DepartmentSalary
WHERE avg_salary > 50000;
Recursive CTE:
WITH RECURSIVE Numbers AS (
SELECT 1 AS num
UNION ALL
SELECT num + 1
FROM Numbers
WHERE num < 10
)
SELECT * FROM Numbers;
@Tajamulkhann
Create an Index:
CREATE INDEX idx_department ON
employees(department);
Unique Index: CREATE UNIQUE INDEX
idx_unique_email ON employees(email);
Drop an Index:
DROP INDEX idx_department;
Clustered Index (SQL Server):
CREATE CLUSTERED INDEX idx_salary ON
employees(salary);
Using EXPLAIN to Optimize:
EXPLAIN SELECT * FROM employees WHERE salary >
50000;
@Tajamulkhann
Follow for more!
