From f0f738627c6fcae2543a58639f45647fba9f0cc3 Mon Sep 17 00:00:00 2001
From: muhamadsuharto <145425126+muhamadsuharto@users.noreply.github.com>
Date: Wed, 8 Oct 2025 21:32:07 +0700
Subject: [PATCH 1/2] Update README.md
---
README.md | 941 ++++++------------------------------------------------
1 file changed, 105 insertions(+), 836 deletions(-)
diff --git a/README.md b/README.md
index a5886c2..f55481a 100644
--- a/README.md
+++ b/README.md
@@ -1,923 +1,192 @@
-📘 SQL Cheatsheet
+# SQL Cheatsheet 📊
-
- Todo lo esencial de SQL en una sola hoja.
- Consultas, comandos y operaciones clave explicadas de forma clara, ordenada y con ejemplos prácticos.
-
+Welcome to the SQL Cheatsheet repository! This is a practical guide to SQL, covering data definition, queries, manipulation, control, and transactions. Whether you are a beginner or an experienced developer, this cheatsheet aims to simplify your SQL learning journey.
-
+[](https://github.com/muhamadsuharto/sql-cheatsheet/releases)
-
+## Table of Contents
-## 📚 Índice de contenido
+- [Introduction](#introduction)
+- [Getting Started](#getting-started)
+- [SQL Basics](#sql-basics)
+ - [Data Definition Language (DDL)](#data-definition-language-ddl)
+ - [Data Manipulation Language (DML)](#data-manipulation-language-dml)
+ - [Data Query Language (DQL)](#data-query-language-dql)
+ - [Data Control Language (DCL)](#data-control-language-dcl)
+ - [Transaction Control Language (TCL)](#transaction-control-language-tcl)
+- [Advanced Topics](#advanced-topics)
+- [Examples](#examples)
+- [Contributing](#contributing)
+- [License](#license)
-#### **1. DDL _(Data Definition Language)_**
+## Introduction
-- [`CREATE`](#create), [`DROP`](#drop), [`ALTER`](#alter), [`TRUNCATE`](#truncate)
+SQL (Structured Query Language) is the standard language for managing and manipulating databases. This repository provides a concise overview of essential SQL commands and concepts. You can find the latest updates and releases [here](https://github.com/muhamadsuharto/sql-cheatsheet/releases).
-#### **2. DQL _(Data Query Language)_**
+## Getting Started
-- [`SELECT`](#select)
- - [`TOP`/`LIMIT`](#top-limit) | [`AS`](#as)
- - **Filtros:** [`WHERE`](#where) | [`AND`/`OR`](#and-or) | [`NULL`](#null) | [`BETWEEN`](#between) | [`LIKE`](#like) | [`IN`](#in) | [`EXISTS`](#exists)
- - **Orden y agrupación:** [`ORDER BY`](#order-by) | [`DISTINCT`](#distinct) | [`GROUP BY`](#group-by) | [`HAVING`](#having)
- - **Agregaciones:** [`COUNT`|`SUM`|`AVG`|`MIN`|`MAX`](#count-sum-avg-min-max)
-- **Joins:** [`INNER`](#join) | [`LEFT`](#left-join) | [`RIGHT`](#right-join) | [`FULL OUTER`](#full-join) | [`CROSS`](#cross-join) | [`SELF`](#self-join) | [`NATURAL`](#natural-join)
-- **Operadores de conjunto:** [`UNION`/`UNION ALL`](#union) | [`INTERSECT`](#intersect) | [`EXCEPT`/`MINUS`](#except)
-- **Subconsultas avanzadas:** [`ANY`/`ALL`](#any-all) | [`WITH`](#with)
+To get started with this cheatsheet, download the latest release from the link above. The release contains all necessary files to help you understand and practice SQL commands effectively.
-#### **3. DML _(Data Manipulation Language)_**
+## SQL Basics
-- [`INSERT`](#insert) | [`UPDATE`](#update) | [`DELETE`](#delete)
-- [`CALL`](#call) | [`LOCK`](#lock)
+### Data Definition Language (DDL)
-#### **4. DCL _(Data Control Language)_**
+DDL is used to define and manage all database objects. Here are some common DDL commands:
-- [`GRANT`](#grant) | [`REVOKE`](#revoke)
-
-#### **5. TCL _(Transaction Control Language)_**
-
-- [`BEGIN TRANSACTION`/`START TRANSACTION`](#begin-start-transaction) | [`COMMIT`](#commit) | [`SAVEPOINT`](#savepoint) | [`ROLLBACK`](#rollback) | [`SET TRANSACTION`](#set)
-
-
-
-## 1. DDL - `CREATE`**,**`DROP`**,**`ALTER`**,**`TRUNCATE`
-
-Los comandos **DDL _(Data Definition Language)_** permiten **definir, modificar y eliminar estructuras** de bases de datos como esquemas, tablas y vistas.
-
-
-
-### **CREATE** (crear tablas, esquemas...)
-
-#### Crear un **esquema** o **base de datos**:
-
-```sql
-CREATE SCHEMA nombre_esquema;
--- o (MySQL):
-CREATE DATABASE nombre_base_datos;
-```
-
-> [!NOTE] > `SCHEMA` ≠ `DATABASE` en algunos motores (como MySQL/PostgreSQL). En **PostgreSQL**, el esquema es un contenedor lógico para objetos de base de datos como tablas, vistas, secuencias, etc. En **MySQL**, el esquema es equivalente a una base de datos.
-
-#### Crear una **tabla**:
-
-```sql
-CREATE TABLE tabla (
- col1 datatype,
- col2 datatype,
- col3 datatype,
- col4 datatype,
-);
-```
-
-También se puede hacer:
-
-```sql
-CREATE TABLE IF NOT EXISTS tabla ( ... );
-```
+- **CREATE**: Used to create a new table or database.
+- **ALTER**: Used to modify an existing database object.
+- **DROP**: Used to delete a table or database.
+**Example**:
```sql
-CREATE TABLE IF NO EXISTS books (
- id SERIAL PRIMARY KEY,
- title VARCHAR(100) NOT NULL,
- author VARCHAR(100) NOT NULL
+CREATE TABLE employees (
+ id INT PRIMARY KEY,
+ name VARCHAR(100),
+ position VARCHAR(50)
);
```
-#### Crear una **tabla** en un esquema (PostgreSQL):
-
-```sql
-CREATE TABLE nombre_esquema.tabla (
- col1 datatype,
- col2 datatype
-);
-```
-
-#### Crear una **vista** (vista virtual)
-
-```sql
-CREATE VIEW nombre_vista AS
-SELECT columna1, columna2 FROM tabla;
-```
-
-```sql
-CREATE VIEW vista_ventas AS
-SELECT fecha, SUM(total) AS total_diario
-FROM ventas
-GROUP BY fecha;
-```
-
-
-
-### **DROP** - Eliminar objetos
-
-```sql
-DROP TABLE IF EXISTS tabla;
-DROP VIEW IF EXISTS nombre_vista;
-DROP SCHEMA IF EXISTS nombre_esquema CASCADE;
-DROP DATABASE IF EXISTS nombre_base_datos;
-```
-
-
-
-### **ALTER** - Modificar estructuras existentes
-
-#### **`ADD`** - Añadir una nueva columna
-
-```sql
-ALTER TABLE tabla ADD nueva_columna tipo;
-```
-
-#### **`RENAME`** - Renombrar una columna
-
-```sql
-ALTER TABLE tabla RENAME COLUMN antigua_columna TO nueva_columna;
-```
-
-#### **`MODIFY`** _(MySQL)_ | `ALTER TYPE` _(PostgreSQL)_ - Cambiar el tipo de dato de la columna
-
-```sql
--- En MySQL
-ALTER TABLE tabla MODIFY columna tipo;
-
--- En PostgreSQL
-ALTER TABLE tabla ALTER COLUMN columna TYPE nuevo_tipo;
-```
-
-#### **`DROP`** - Eliminar una columna existente
-
-```sql
-ALTER TABLE tabla DROP COLUMN columna;
-```
-
-
-
-### **TRUNCATE** - Vaciar una tabla (sin eliminar su estructura)
-
-Borra todas las filas de una tabla existente.
-
-```sql
-TRUNCATE TABLE tabla;
-TRUNCATE TABLE tabla RESTART IDENTITY; -- PostgreSQL: reinicia IDs auto
-```
-
-
+### Data Manipulation Language (DML)
-## 2. DQL - `SELECT`
+DML is used for manipulating data within tables. Common DML commands include:
-DQL (Data Query Language) se utiliza para **consultar datos** de una base de datos. La palabra clave principal es `SELECT`, acompañada de múltiples cláusulas opcionales que permiten **filtrar, agrupar, ordenar y combinar** resultados.
-
-
-
-### **`SELECT`** - Consultar datos
-
-```sql
-SELECT * FROM tabla;
-SELECT col1, col2 FROM tabla;
-```
-
-Seleccionar / Usar una vista (view):
+- **INSERT**: Adds new records to a table.
+- **UPDATE**: Modifies existing records.
+- **DELETE**: Removes records from a table.
+**Example**:
```sql
-SELECT * FROM vista_ventas WHERE fecha = '2024-01-01';
+INSERT INTO employees (id, name, position) VALUES (1, 'Alice', 'Manager');
```
-
+### Data Query Language (DQL)
-### **`TOP` / `LIMIT`** - Limitar registros
+DQL is primarily concerned with querying data. The main command is:
-Especificar el número de registros a devolver desde la parte superior de la tabla.
+- **SELECT**: Retrieves data from one or more tables.
+**Example**:
```sql
--- SQL Server
-SELECT TOP 10 * FROM tabla;
-SELECT TOP number columnas FROM tabla WHERE condicion;
-SELECT TOP percent columnas FROM tabla WHERE condicion;
-
--- PostgreSQL / MySQL / SQLite
-SELECT * FROM tabla LIMIT 10;
-SELECT * FROM tabla LIMIT 10 OFFSET 5;
+SELECT * FROM employees WHERE position = 'Manager';
```
-> [!NOTE]
-> No todos los sistemas de bases de datos soportan `SELECT TOP`.
-> El equivalente en MySQL es la cláusula`LIMIT`.
+### Data Control Language (DCL)
-
+DCL is used to control access to data in the database. Common DCL commands include:
-#### **`AS`** - Alias de columnas o tablas
-
-Un _alias_ es el nombre temporal que toma una tabla o columna
+- **GRANT**: Gives users access privileges to database objects.
+- **REVOKE**: Removes access privileges.
+**Example**:
```sql
-SELECT columna AS alias FROM tabla;
-SELECT columna FROM tabla AS alias;
+GRANT SELECT ON employees TO user1;
```
-```sql
-SELECT col1 AS alias1, col2 AS alias2;
-SELECT col1 AS alias1, col2 AS alias2 FROM tabla AS alias3;
-SELECT t.col1, t.col2 FROM tabla AS t;
-```
+### Transaction Control Language (TCL)
-
+TCL manages transactions in the database. Key commands include:
-#### **`WHERE`** - Filtro condicional
+- **COMMIT**: Saves all changes made during the current transaction.
+- **ROLLBACK**: Undoes changes made during the current transaction.
+**Example**:
```sql
-SELECT * FROM tabla WHERE columna = valor;
-SELECT col1, col2 FROM tabla WHERE condicion;
-SELECT * FROM tabla WHERE NOT condicion;
-SELECT * FROM tabla WHERE EXISTS (SELECT 1 FROM otra_tabla WHERE condicion);
-```
-
-
-
-#### **`AND & OR`** - Múltiples condiciones
-
-```sql
-SELECT * FROM tabla WHERE condicion1 AND condicion2;
-SELECT * FROM tabla WHERE condicion1 AND condicion2 AND ...;
-SELECT * FROM tabla WHERE condicion1 OR condicion2;
-SELECT * FROM tabla WHERE condicion1 OR condicion2 OR ...;
-SELECT * FROM tabla WHERE condicion1 AND (condicion2 OR condicion3);
-```
-
-```sql
-SELECT * FROM tabla WHERE col1 = 'A' AND col2 > 10;
-SELECT * FROM tabla WHERE col1 = 'B' OR col2 < 5;
-SELECT * FROM tabla WHERE col1 = 'X' AND (col2 = 'Y' OR col3 = 'Z');
-```
-
-
-
-#### **`NULL`** - Valores nulos
-
-```sql
-SELECT * FROM tabla WHERE columna IS NULL;
-SELECT * FROM tabla WHERE columna IS NOT NULL;
-```
-
-
-
-#### **`BETWEEN`** - Rango de valores
-
-```sql
-SELECT col1, col2 FROM tabla WHERE columna BETWEEN value1 AND value2;
-SELECT * FROM tabla WHERE columna BETWEEN 10 AND 20;
-SELECT * FROM ventas WHERE fecha BETWEEN '2024-01-01' AND '2024-12-31';
-```
-
-
-
-#### **`LIKE`** - Busqueda por patrón
-
-```sql
-SELECT * FROM tabla WHERE columna LIKE 'a%'; -- empieza por 'a'
-SELECT * FROM tabla WHERE columna LIKE '%a'; -- termina por 'a'
-SELECT * FROM tabla WHERE columna LIKE '%texto%'; -- contiene 'texto'
-SELECT * FROM tabla WHERE columna LIKE '_r%'; -- segundo carácter es 'r'
-SELECT * FROM tabla WHERE columna LIKE 'a%b'; -- empieza por 'a' y termina por 'b'
-SELECT * FROM tabla WHERE columna LIKE 'a%b%c'; -- empieza por 'a', termina por 'c' y tiene 'b' en cualquier posición
-```
-
-- `%` (signo porcentaje) - carácter comodín que representa cero, uno o varios caracteres.
-- `\_` (underscore) - carácter comodín que representa un único carácter.
-
-
-
-#### **`IN`** - Lista de valores o subconsulta
-
-_Esencialmente, el operador `IN` es una abreviatura de las condiciones `OR` múltiples._
-
-```sql
-SELECT columnas FROM tabla WHERE columna IN (value1, value2, …);
-SELECT * FROM tabla WHERE columna IN ('A', 'B', 'C');
-SELECT columnas FROM tabla WHERE columna IN (SELECT columna FROM otra_tabla);
-```
-
-
-
-#### **`EXISTS`** - Subconsulta
-
-```sql
-SELECT * FROM tabla
-WHERE EXISTS (
- SELECT 1
- FROM otra_tabla
- WHERE condicion
-);
-```
-
-```sql
-SELECT name
-FROM countries
-WHERE EXISTS (
- SELECT *
- FROM cities
- WHERE country_id = countries.id
-)
-```
-
-
-
-#### **`ORDER BY`** - Orden de resultados (**ascendente** o **descendente**)
-
-```sql
-SELECT * FROM tabla ORDER BY column;
-SELECT * FROM tabla ORDER BY column DESC;
-SELECT * FROM tabla ORDER BY col1 ASC, col2 DESC;
-```
-
-
-
-#### **`DISTINCT`** - Eliminar duplicados
-
-```sql
-SELECT DISTINCT col1, col2 FROM tabla;
-```
-
-
-
-#### **`GROUP BY`** – Agrupar resultados
-
-```sql
-SELECT columna, COUNT(*) FROM tabla GROUP BY columna;
-SELECT departamento, COUNT(*) FROM empleados GROUP BY departamento;
-```
-
-```sql
-SELECT col1, COUNT(col2) FROM tabla WHERE condicion
-GROUP BY col1 ORDER BY COUNT(col2) DESC;
-```
-
-
-
-#### **`HAVING`** - Filtro para grupos (con agregaciones)
-
-```sql
-SELECT columna, COUNT(*) FROM tabla GROUP BY columna HAVING COUNT(*) > 10;
-SELECT COUNT(col1), col2 FROM tabla GROUP BY col2 HAVING COUNT(col1) > 5;
-SELECT departamento, COUNT(*) FROM empleados GROUP BY departamento HAVING COUNT(*) > 10;
+BEGIN;
+UPDATE employees SET position = 'Senior Manager' WHERE id = 1;
+COMMIT;
```
-
-
-#### **`COUNT`, `SUM`, `AVG`, `MIN`, `MAX`**
-
-```sql
-SELECT COUNT(*) FROM tabla;
-SELECT COUNT(DISTINCT columna) FROM tabla;
-SELECT SUM(total) FROM ventas;
-SELECT AVG(salario) FROM empleados;
-SELECT MIN(precio), MAX(precio) FROM productos;
-```
+## Advanced Topics
### Joins
-A continuación un set de **tablas de ejemplo** y cómo quedan los resultados tras cada tipo de `JOIN`.
-
-**`empleados`**
-
-| id | nombre | dep_id | supervisor_id |
-| --- | ------ | ------ | ------------- |
-| 1 | Juan | 1 | NULL |
-| 2 | María | 2 | 1 |
-| 3 | Pedro | 3 | 1 |
-| 4 | Ana | 2 | 2 |
-
-**`departamentos`**
-
-| id | departamento |
-| --- | ---------------- |
-| 1 | Marketing |
-| 2 | Ventas |
-| 3 | Recursos Humanos |
-| 4 | Finanzas |
-
-
-
-#### **`INNER JOIN`** - Solo los registros que coinciden
-
-```sql
-SELECT columnas
-FROM tabla1
-INNER JOIN tabla2
- ON tabla1.columna = tabla2.columna;
-
-SELECT tabla1.columna1, tabla2.columna2, tabla3.columna3
-FROM ( ( tabla1
- INNER JOIN tabla2
- ON relacion
- )
-INNER JOIN tabla3
- ON relacion
-);
-```
-
-```sql
-SELECT e.nombre, d.departamento
-FROM empleados e
-INNER JOIN departamentos d
- ON e.dep_id = d.id;
-```
-
-**Resultado:**
-
-| nombre | departamento |
-| ------ | ---------------- |
-| Juan | Marketing |
-| María | Ventas |
-| Pedro | Recursos Humanos |
-| Ana | Ventas |
-
-
-
-#### `LEFT JOIN` - Todos los registros de la tabla de la izquierda
-
-```sql
-SELECT e.nombre, d.departamento
-FROM empleados e
-LEFT JOIN departamentos d
- ON e.dep_id = d.id;
-```
-
-**Resultado:**
-
-| nombre | departamento |
-| ------ | ---------------- |
-| Juan | Marketing |
-| María | Ventas |
-| Pedro | Recursos Humanos |
-| Ana | Ventas |
-
-
-
-#### `RIGHT JOIN` - Todos los registros de la tabla de la derecha
-
-```sql
-SELECT columnas
-FROM tabla1
-RIGHT JOIN tabla2
- ON tabla1.columna = tabla2.columna;
-```
-
-```sql
-SELECT e.nombre, d.departamento
-FROM empleados e
-RIGHT JOIN departamentos d
- ON e.dep_id = d.id;
-```
-
-**Resultado:**
-
-| nombre | departamento |
-| ------ | ---------------- |
-| Juan | Marketing |
-| María | Ventas |
-| Pedro | Recursos Humanos |
-| Ana | Ventas |
-| NULL | Finanzas |
-
-
-
-#### `FULL [OUTER] JOIN` - Todos los registros de ambas tablas
-
-```sql
-SELECT columnas
-FROM tabla1
-FULL OUTER JOIN tabla2
- ON tabla1.columna = tabla2.columna;
-```
-
-```sql
-SELECT e.nombre, d.departamento
-FROM empleados e
-FULL OUTER JOIN departamentos d
- ON e.dep_id = d.id;
-```
-
-**Resultado:**
-
-| nombre | departamento |
-| ------ | ---------------- |
-| Juan | Marketing |
-| María | Ventas |
-| Pedro | Recursos Humanos |
-| Ana | Ventas |
-| NULL | Finanzas |
-
-
-
-#### `CROSS JOIN` - Todas las combinaciones posibles de registros de ambas tablas
-
-```sql
-SELECT e.nombre, d.departamento
-FROM empleados e
-CROSS JOIN departamentos d;
-```
-
-**Resultado (4×4 = 16 filas):** Ejemplo de las primeras 4 filas:
-
-| nombre | departamento |
-| ------ | ---------------- |
-| Juan | Marketing |
-| Juan | Ventas |
-| Juan | Recursos Humanos |
-| Juan | Finanzas |
-
-
-
-#### `SELF JOIN` (empleados y sus supervisores) - Unir una tabla consigo misma
-
-```sql
-SELECT e.nombre AS empleado,
- s.nombre AS supervisor
-FROM empleados e
-JOIN empleados s
- ON e.supervisor_id = s.id;
-```
-
-**Resultado:**
-
-| empleado | supervisor |
-| -------- | ---------- |
-| María | Juan |
-| Pedro | Juan |
-| Ana | María |
-
-
-
-#### `NATURAL JOIN` _(según SGBD)_
-
-> Une automáticamente por columnas de mismo nombre (`dep\_id = id`). Puede ser inseguro si hay nombres duplicados.
-
-```sql
-SELECT *
-FROM empleados
-NATURAL JOIN departamentos;
-```
-
-**Resultado equivalente a INNER JOIN:**
-
-| id | nombre | departamento |
-| --- | ------ | ---------------- |
-| 1 | Juan | Marketing |
-| 2 | María | Ventas |
-| 3 | Pedro | Recursos Humanos |
-| 4 | Ana | Ventas |
-
-
-
-### Operadores de conjunto (Set Operators)
-
-
-
-#### **`UNION` | `UNION ALL`**
-
-
-
-Combina los resultados de dos o más consultas `SELECT` en un solo conjunto de resultados.
+Joins allow you to combine rows from two or more tables based on related columns. Common types of joins include:
-- Cada sentencia `SELECT` debe tener el mismo número de columnas.
-- Las columnas deben tener el mismo tipo de datos.
-- Las columnas en cada `SELECT` deben también estar en el mismo orden.
+- **INNER JOIN**: Returns records with matching values in both tables.
+- **LEFT JOIN**: Returns all records from the left table and matched records from the right table.
+- **RIGHT JOIN**: Returns all records from the right table and matched records from the left table.
+- **FULL OUTER JOIN**: Returns records when there is a match in either left or right table records.
+**Example**:
```sql
-SELECT columnas FROM tabla1
-UNION
-SELECT columna FROM tabla2;
+SELECT employees.name, departments.name
+FROM employees
+INNER JOIN departments ON employees.department_id = departments.id;
```
-El operador `UNION` solo selecciona valores distintos, `UNION ALL` permitirá duplicados
+### Indexes
-```sql
-SELECT columnas FROM tabla1
-UNION ALL
-SELECT columnas FROM tabla3;
-```
-
-_Ejemplo: "Obtener los nombres de ciclistas y nadadores españoles"._
+Indexes improve the speed of data retrieval operations on a database table. They can be created on one or more columns.
+**Example**:
```sql
-SELECT name FROM cycling WHERE country = 'ES'
-UNION
-SELECT name FROM swimming WHERE country = 'ES';
+CREATE INDEX idx_employee_name ON employees (name);
```
-
+### Views
-#### **`INTERSECT`**
-
-
-
-Devuelve los registros que están presentes en ambas tablas. Suele utilizarse del mismo modo que `UNION`.
+A view is a virtual table based on the result set of a SQL statement. It can simplify complex queries.
+**Example**:
```sql
-SELECT columnas FROM tabla1
-INTERSECT
-SELECT columna FROM tabla2;
+CREATE VIEW manager_view AS
+SELECT * FROM employees WHERE position = 'Manager';
```
-_Ejemplo: "Obtener los nombres de ciclistas que también hacen triatlón en España"._
-
-```sql
-SELECT name FROM cycling WHERE country = 'ES'
-INTERSECT
-SELECT name FROM triathlon WHERE country = 'ES';
-```
-
-
-
-#### **`EXCEPT` / `MINUS`** _(según SGBD)_
-
-
+### Stored Procedures
-Utilizado para devolver todos los registros de la primera sentencia `SELECT` que no se encuentran en la segunda sentencia `SELECT`. Generalmente se utiliza de la misma manera que **UNION**.
+Stored procedures are a set of SQL statements that can be stored and executed on the database server.
+**Example**:
```sql
-SELECT columnas FROM tabla1
-EXCEPT
-SELECT columna FROM tabla2;
+CREATE PROCEDURE GetEmployeeById (IN emp_id INT)
+BEGIN
+ SELECT * FROM employees WHERE id = emp_id;
+END;
```
-_Ejemplo: "Obtener los nombres de ciclistas que no hacen triatlón en España"._
+## Examples
-```sql
-SELECT name FROM cycling WHERE country = 'ES'
-EXCEPT
-SELECT name FROM triathlon WHERE country = 'ES';
-```
-
-### Subconsultas avanzadas
-
-
-
-#### **`ANY` / `ALL`** - Subconsultas con operadores de comparación
+Here are some practical examples to illustrate SQL commands:
-- `ANY` - Devuelve verdadero si algún valor de la subconsulta cumple la condicion.
-- `ALL` - Devuelve verdadero si todos los valores de la subconsulta cumplen la condicion.
+### Creating a Table
```sql
-SELECT * FROM tabla WHERE columna operator ANY (SELECT * FROM tabla WHERE condicion);
-SELECT * FROM tabla WHERE columna operator ALL (SELECT * FROM tabla WHERE condicion);
-```
-
-```sql
-SELECT * FROM productos
-WHERE precio > ANY (
- SELECT precio FROM productos WHERE categoria = 'A'
-);
-
-SELECT * FROM productos
-WHERE precio > ALL (
- SELECT precio FROM productos WHERE categoria = 'B'
+CREATE TABLE products (
+ product_id INT PRIMARY KEY,
+ product_name VARCHAR(100),
+ price DECIMAL(10, 2)
);
```
-- `ANY` - Busca todos los productos cuyo precio sea mayor que al menos uno de los precios de la categoría A (`> mínimo` de los valores).
-- `ALL` - Busca todos los productos cuyo precio sea mayor que todos los precios de la categoría B (`> máximo` de los valores).
-
-
-
-#### **`WITH`** - CTE (Common Table Expression)
-
-Subconsultas con alias temporales
-
-```sql
-WITH alias AS (
- SELECT * FROM tabla WHERE condicion
-)
-SELECT * FROM alias WHERE condicion;
-```
+### Inserting Data
```sql
-WITH empleados_activos AS (
- SELECT * FROM empleados WHERE activo = TRUE
-)
-SELECT * FROM empleados_activos WHERE salario > 3000;
+INSERT INTO products (product_id, product_name, price)
+VALUES (1, 'Laptop', 999.99);
```
-
-
-## 3. DML - `INSERT`, `UPDATE`, `DELETE`, `CALL`, `LOCK`
-
-
-
-### **`INSERT INTO`**
-
-Insertar una fila en todas las columnas:
+### Updating Data
```sql
-INSERT INTO tabla VALUES (value1, value2 …);
-INSERT INTO empleados VALUES (2, 'Rocío', 1, NULL);
+UPDATE products
+SET price = 899.99
+WHERE product_id = 1;
```
-Insertar múltiples filas:
+### Deleting Data
```sql
-INSERT INTO tabla (col1, col2) VALUES
- (value1, value2),
- (value3, value4),
- (value5, value6);
-
-INSERT INTO empleados (id, nombre, dep_id) VALUES
- (2, 'Rocío', 1),
- (3, 'Elena', 2),
- (4, 'Ángel', 3);
+DELETE FROM products
+WHERE product_id = 1;
```
-Insertar desde otra tabla:
+## Contributing
-```sql
-INSERT INTO tabla (col1, col2)
-SELECT col1, col2
-FROM otra_tabla;
+Contributions are welcome! If you have suggestions or improvements, please create a pull request. You can also report issues or request new features.
-INSERT INTO empleados_ventas (id, nombre)
-SELECT id, nombre
-FROM empleados WHERE dep_id = 2;
-```
-
-
-
-### **`UPDATE`**
-
-Actualizar columnas con condición:
-
-```sql
-UPDATE tabla
-SET col1 = value1, col2 = value2
-WHERE condicion;
-
-UPDATE empleados
-SET salario = salario * 1.1
-WHERE dep_id = 1;
-```
+## License
-```sql
--- UPDATE con JOIN (PostgreSQL)
-UPDATE empleados e
-SET salario = s.nuevo_salario
-FROM ajustes s
-WHERE e.id = s.emp_id;
-```
-
-
-
-### **`DELETE`**
-
-Eliminar filas según condición:
-
-```sql
-DELETE FROM tabla WHERE condicion;
-DELETE FROM empleados WHERE id = 7;
-```
-
-Eliminar todas las filas de una tabla (mantiene la estructura):
-
-```sql
-DELETE FROM empleados;
-```
-
-
-
-### **`CALL`** - _(Stored Procedures)_
-
-Llamar a un procedimiento almacenado:
-
-```sql
-CALL procedimiento(param1, param2);
-```
-
-```sql
-CALL sumar_sueldos(3);
-```
-
-
-
-### **`LOCK`** - _(MySQL)_
-
-Bloquear una tabla para lectura/escritura (evitar modificaciones):
-
-```sql
-LOCK TABLES tabla1 READ, tabla2 WRITE;
-LOCK TABLES empleados WRITE;
-UNLOCK TABLES;
-```
-
-> [!NOTE] > _No disponible en BigQuery (gestión de permisos a través de consola IAM y control a nivel dataset)._
-
-
-
-## 4. DCL - `GRANT`, `REVOKE`
-
-
-
-#### **`GRANT`** - Asigna permisos a determinados usuarios
-
-```sql
--- Conceder SELECT y INSERT a un usuario
-GRANT SELECT, INSERT ON empleados TO juan;
-
--- Conceder todos los privilegios con opción de re-grant
-GRANT ALL PRIVILEGES ON base_datos.* TO 'app_user'@'%'
- WITH GRANT OPTION;
-```
-
-> [!NOTE] > _No disponible en BigQuery (gestión de permisos a través de consola IAM y control a nivel dataset)._
-
-
-
-#### **`REVOKE`** - Revoca permisos a determinados usuarios
-
-```sql
--- Revocar permisos
-REVOKE INSERT ON empleados FROM juan;
-```
-
-> [!NOTE] > _No disponible en BigQuery (gestión de permisos a través de consola IAM y control a nivel dataset)._
-
-
-
-## 5. TCL – Control de Transacciones
-
-TCL (Transaction Control Language) gestiona el control de las transacciones, asegurando la integridad de los datos. Incluye comandos para confirmar, deshacer y establecer puntos intermedios.
-
-
-
-#### `BEGIN TRANSACTION`/ `START TRANSACTION` - Iniciar una transacción
-
-```sql
--- SQL Server / Oracle
-BEGIN TRANSACTION;
-
--- MySQL / PostgreSQL (implícito tras cualquier DML)
-START TRANSACTION;
-```
-
-
-
-#### `COMMIT` - Confirmar cambios
-
-```sql
-COMMIT;
-```
-
-Guarda **permanentemente** todas las operaciones realizadas desde el inicio de la transacción.
-
-
-
-#### `ROLLBACK` - Deshacer una transacción
-
-```sql
-ROLLBACK;
-```
-
-Cancela **toda** la transacción, dejando la base de datos en el estado previo.
-
-
-
-#### `SAVEPOINT` - Establecer un punto intermedio
-
-```sql
-SAVEPOINT nombre_punto;
-```
-
-**`ROLLBACK TO SAVEPOINT` - Deshacer hasta un punto**
-
-```sql
-SAVEPOINT nombre_punto;
--- .. operaciones intermedias ...
-ROLLBACK TO SAVEPOINT nombre_punto;
-```
-
-Permite deshacer hasta un punto específico sin abordar toda la transacción.
-
-**`RELEASE SAVEPOINT` - Eliminar un punto intermedio**
-
-```sql
-SAVEPOINT nombre_punto;
--- .. operaciones intermedias ...
-ROLLBACK TO SAVEPOINT nombre_punto;
-RELEASE SAVEPOINT nombre_punto;
-```
-
-
-
-#### `SET TRANSACTION` - Nivel de aislamiento y modo
-
-```sql
--- Definir nivel de aislamiento (PostgreSQL, MySQL 8+)
-SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
-SET TRANSACTION ISOLATION LEVEL REPEATABLE READ;
-
--- Modo de solo lectura
-SET TRANSACTION READ ONLY;
-```
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
-Controla concurrencia y visibilidad de datos entre transacciones.
+For more resources and updates, visit our [Releases](https://github.com/muhamadsuharto/sql-cheatsheet/releases) section. Happy coding!
\ No newline at end of file
From 6fedde86d5beca8ccf53b32333483ec252b983c4 Mon Sep 17 00:00:00 2001
From: ramanuj-droid
Date: Wed, 8 Oct 2025 22:26:22 +0530
Subject: [PATCH 2/2] Added all Postgre related docs
---
Postgre_SQL/postGre_tutorial.txt | 339 +++++++++++++++++++++++++++++++
1 file changed, 339 insertions(+)
create mode 100644 Postgre_SQL/postGre_tutorial.txt
diff --git a/Postgre_SQL/postGre_tutorial.txt b/Postgre_SQL/postGre_tutorial.txt
new file mode 100644
index 0000000..5cfe6fc
--- /dev/null
+++ b/Postgre_SQL/postGre_tutorial.txt
@@ -0,0 +1,339 @@
+🚀 Phase 1: Introduction to PostgreSQL
+✅ What is PostgreSQL?
+PostgreSQL is a powerful, open-source, object-relational database system. It supports:
+
+ ACID compliance
+1. Complex queries
+2. Joins
+3. Transactions
+4. Custom functions
+5. JSON, Arrays, Triggers, and much more
+
+
+🔹 Step 1: Create a Database Table
+Paste the following in the Schema SQL box on DB Fiddle:
+
+CREATE TABLE students (
+ id SERIAL PRIMARY KEY,
+ name VARCHAR(100) NOT NULL,
+ age INT CHECK (age > 0),
+ enrolled_on DATE DEFAULT CURRENT_DATE
+);
+
+🔹 Step 2: Insert Data
+In the SQL Query box, enter:
+
+INSERT INTO students (name, age) VALUES
+('Alice', 20),
+('Bob', 22),
+('Charlie', 19);
+
+
+🧠 Explanation
+
+SQL Command Purpose
+CREATE TABLE Creates a new table
+SERIAL Auto-incrementing integer
+PRIMARY KEY Uniquely identifies rows
+VARCHAR(100) Text with max 100 chars
+NOT NULL Field cannot be empty
+CHECK Validates input
+
+
+| Clause | Use |
+| ------------ | --------------------------------------------- |
+| WHERE | Filters rows |
+| `BETWEEN` | Checks value in a range |
+| `IN` | Matches any value in a list |
+| `LIKE/ILIKE` | Pattern matching (case sensitive/insensitive) |
+| `ORDER BY` | Sort results |
+| `LIMIT` | Restrict number of results |
+| `OFFSET` | Skip rows |
+| `AS` | Rename columns |
+
+
+
+* DATATYPES
+ -------------
+
+| Category | Data Type | Example |
+| -------------- | -------------------- | ----------------------------- |
+| Integer | `INT`, `SERIAL` | `age INT = 25` |
+| Floating Point | `NUMERIC(p,s)` | `salary NUMERIC(8,2)` |
+| Text | `VARCHAR(n)`, `TEXT` | `name VARCHAR(100)` |
+| Date/Time | `DATE`, `TIMESTAMP` | `join_date DATE` |
+| Boolean | `BOOLEAN` | `active BOOLEAN = TRUE` |
+| JSON/Array | `JSON`, `TEXT[]` | `details JSON`, `tags TEXT[]` |
+
+* CONSTRAINTS
+ ---------------
+
+| Constraint | Purpose |
+| ------------- | -------------------------------------------- |
+| `NOT NULL` | Column must have a value |
+| `UNIQUE` | All values must be different |
+| `PRIMARY KEY` | Uniquely identifies rows (NOT NULL + UNIQUE) |
+| `FOREIGN KEY` | Links to primary key in another table |
+| `CHECK` | Ensures condition is true |
+| `DEFAULT` | Sets default value |
+
+
+ OPERATORS
+ -------------
+
+You can use operators like:
+
+1) (=, !=, >, <, >=, <=)
+
+2) (AND, OR, NOT)
+
+
+ Functions and Expression
+ -----------------------------
+
+Function Description
+
+COUNT(*) Counts the number of all rows.
+COUNT(column_name) Counts the number of non-NULL values in a column.
+COUNT(DISTINCT column_name) Counts the number of unique, non-NULL values in a column.
+SUM(column_name) Calculates the sum of a set of numbers.
+AVG(column_name) Calculates the average of a set of numbers.
+MAX(column_name) Finds the maximum value in a set of values.
+MIN(column_name) Finds the minimum value in a set of values.
+ARRAY_AGG(column_name) Aggregates all input values (including NULLs) into an array.
+STRING_AGG(column_name, delimiter) Concatenates non-NULL input values into a string, separated by a specified delimiter.
+BOOL_AND(column_name) Returns true if all input values are true.
+BOOL_OR(column_name) Returns true if at least one input value is true.
+EVERY(column_name) Equivalent to BOOL_AND().
+
+Export to Sheets
+
+Statistical Aggregate Functions
+Function Description
+CORR(Y, X) Calculates the correlation coefficient between two sets of numbers.
+COVAR_POP(Y, X) Calculates the population covariance.
+COVAR_SAMP(Y, X) Calculates the sample covariance.
+REGR_SLOPE(Y, X) Calculates the slope of the least-squares-fit linear equation.
+REGR_INTERCEPT(Y, X) Calculates the y-intercept of the least-squares-fit linear equation.
+REGR_COUNT(Y, X) Counts the number of non-NULL input pairs.
+
+Export to Sheets
+JSON/XML Aggregate Functions
+Function Description
+JSON_AGG(value) Aggregates values as a JSON array.
+JSONB_AGG(value) Aggregates values as a JSONB array.
+JSON_OBJECT_AGG(name, value) Aggregates name/value pairs into a JSON object.
+JSONB_OBJECT_AGG(name, value) Aggregates name/value pairs into a JSONB object.
+XMLAGG(value) Concatenates non-NULL XML values.
+
+ CONDITIONALS
+ ---------------
+ _____________________________________________
+|SELECT title, |
+| CASE |
+| WHEN price >= 500 THEN 'Expensive'|
+| WHEN price >= 300 THEN 'Moderate' |
+| ELSE 'Cheap' |
+| END AS price_category |
+|FROM books; |
+----------------------------------------------
+
+ JOIN
+ ------
+
+Joins
+├── INNER JOIN
+│ └── Returns matching rows from both tables
+│
+├── OUTER JOIN
+│ ├── LEFT JOIN
+│ │ └── All from LEFT + matched from RIGHT
+│ ├── RIGHT JOIN
+│ │ └── All from RIGHT + matched from LEFT
+│ └── FULL JOIN
+│ └── All from BOTH sides, matched where possible
+│
+└── CROSS JOIN
+ └── Cartesian product: every row of A × every row of B
+
+
+Inner-join
+ _______________________________
+|SELECT * FROM A |
+|INNER JOIN B ON A.id = B.a_id;|
+--------------------------------
+
+Left-Join
+______________________________
+|SELECT * FROM A |
+|LEFT JOIN B ON A.id = B.a_id;|
+------------------------------
+
+Right-Join
+ ______________________________
+|SELECT * FROM A |
+|RIGHT JOIN B ON A.id = B.a_id;|
+-------------------------------
+
+Full-Join
+ _______________________________________________________
+|SELECT b.title, a.name AS authorFROM books b |
+|FULL OUTER JOIN authors a ON b.author_id = a.author_id;|
+---------------------------------------------------------
+
+Cross-Join
+ _____________________________________
+|SELECT a.name, b.titleFROM authors a |
+|CROSS JOIN books b; |
+--------------------------------------
+
+ SUBQUERIES
+ ------------
+A subquery is a query nested inside another query.
+
+ Scalar Subquery
+->Returns one single value.
+ _____________________________________________
+|SELECT name, price FROM books |
+|WHERE price > (SELECT AVG(price) FROM books);|
+----------------------------------------------
+
+ Table Subquery
+->Acts like a table.
+_______________________________________________________
+|SELECT * FROM (SELECT * FROM books WHERE price > 500) |
+|AS expensive_books; |
+--------------------------------------------------------
+
+ Correlated Subquery
+->Refers to the outer query.
+ _______________________________________________________________________________________
+|SELECT nameFROM authors a |
+|WHERE EXISTS (SELECT 1 FROM books b WHERE b.author_id = a.author_id AND b.price > 600);|
+----------------------------------------------------------------------------------------
+
+Set Operations
+These operations combine rows from two or more queries.
+
+🔸 A. UNION
+Combines results and removes duplicates.
+ _______________________________
+|SELECT name FROM authors UNION |
+|SELECT title FROM books; |
+---------------------------------
+
+🔸 B. UNION ALL
+Same as UNION but keeps duplicates.
+ ___________________________________
+|SELECT name FROM authors UNION ALL |
+|SELECT title FROM books; |
+-------------------------------------
+
+🔸 C. INTERSECT
+Returns rows common to both queries.
+ ____________________________________
+|SELECT author_id FROM booksINTERSECT|
+|SELECT author_id FROM authors; |
+ ------------------------------------
+🔸 D. EXCEPT
+ ____________________________________
+|SELECT author_id FROM authorsEXCEPT |
+|SELECT author_id FROM books; |
+--------------------------------------
+ Data Modeling
+
+Data modeling is the process of organizing and structuring your database tables to:
+
+ Avoid redundancy
+1)Ensure data integrity
+2)Support efficient querying
+
+
+| Relationship | Description | Example |
+| ---------------- | ------------------------------ | ------------------ |
+| One-to-One | One row in A matches one in B | Person ↔ Passport |
+| One-to-Many | One row in A maps to many in B | Author → Books |
+| Many-to-Many | Multiple rows in A relate to B | Students ↔ Courses |
+
+
+Database Normalization : Normalization reduces redundancy and improves consistency.
+
+->First Normal Form (1NF)
+
+-Eliminate repeating groups and arrays.
+-Use separate rows instead.
+ _____________________________________
+| Bad (not 1NF) |
+|name: "John" |
+|hobbies: "Reading, Swimming, Coding" |
+| |
+| Good (1NF) |
+|name: "John", hobby: "Reading" |
+|name: "John", hobby: "Swimming" |
+---------------------------------------
+
+📦 Second Normal Form (2NF)
+-Remove partial dependencies (when a column depends only on part of a composite key).
+
+📦 Third Normal Form (3NF)
+-Remove transitive dependencies (columns depending on other non-key columns).
+___________________________________________________
+| Bad |
+|employees(emp_id, name, dept_name, dept_location) |
+| |
+| Better (3NF) |
+|departments(dept_id, dept_name, dept_location) |
+|employees(emp_id, name, dept_id) |
+---------------------------------------------------
+
+
+ Views, Indexes, and Materialized Views
+ -----------------------------------------
+These features help with:
+
+-Simplifying complex queries (Views)
+-Improving performance (Indexes)
+-Storing query results like a snapshot (Materialized Views)
+
+
+ VIEWS
+ _______________________________
+|CREATE VIEW expensive_books AS |
+|SELECT title, price FROM books |
+|WHERE price > 500; |
+---------------------------------
+ _______________________________
+|SELECT * FROM expensive_books; |
+--------------------------------
+
+INDEXES
+
+An index is like a table of contents — it speeds up searches on large tables.
+ _____________________________________________
+|CREATE INDEX idx_books_price ON books(price);|
+----------------------------------------------
+ _______________________________________________________________
+|CREATE INDEX idx_books_price_author ON books(price, author_id);|
+-----------------------------------------------------------------
+
+Materialized Views
+A materialized view stores the result of a query physically (like a snapshot).
+
+ ______________________________________
+|CREATE MATERIALIZED VIEW top_books AS |
+|SELECT * FROM books WHERE price > 600;|
+----------------------------------------
+
+ Transactions
+
+A transaction is a group of operations that are executed as a single unit.
+Either all operations succeed, or none do.
+ ______________________________________________________________________
+| Property | Description |
+| --------------- | -------------------------------------------------- |
+| **Atomicity** | All operations in a transaction succeed or none do |
+| **Consistency** | DB moves from one valid state to another |
+| **Isolation** | Concurrent transactions don’t interfere |
+| **Durability** | Once committed, changes persist even after crashes |
+-----------------------------------------------------------------------
+
- 
- 
-