Scribd
Upload
154 views16 pages

SQL Cheatsheet

The document outlines various SQL commands and functions for database management, including creating, altering, and deleting tables, as well as performing queries and data manipulation. It covers key SQL operations such as SELECT, JOIN, and aggregate functions, along with transaction control and the use of stored procedures and triggers. Additionally, it includes examples of using common table expressions (CTEs) and indexing for optimization.

Uploaded by

monhold1
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
154 views16 pages

SQL Cheatsheet

The document outlines various SQL commands and functions for database management, including creating, altering, and deleting tables, as well as performing queries and data manipulation. It covers key SQL operations such as SELECT, JOIN, and aggregate functions, along with transaction control and the use of stored procedures and triggers. Additionally, it includes examples of using common table expressions (CTEs) and indexing for optimization.

Uploaded by

monhold1
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 16

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!

You might also like