@vodailoc/kilo-kit-mcp 1.1.0 → 1.1.1

package/skills/engineering/databases/references/postgresql-queries.md

@@ -1,475 +1,475 @@
-# PostgreSQL SQL Queries
-
-SQL queries in PostgreSQL: SELECT, JOINs, subqueries, CTEs, window functions, and advanced patterns.
-
-## Basic SELECT
-
-### Simple Queries
-```sql
--- Select all columns
-SELECT * FROM users;
-
--- Select specific columns
-SELECT id, name, email FROM users;
-
--- With alias
-SELECT name AS full_name, email AS contact_email FROM users;
-
--- Distinct values
-SELECT DISTINCT status FROM orders;
-
--- Count rows
-SELECT COUNT(*) FROM users;
-SELECT COUNT(DISTINCT status) FROM orders;
-```
-
-### WHERE Clause
-```sql
--- Equality
-SELECT * FROM users WHERE status = 'active';
-
--- Comparison
-SELECT * FROM products WHERE price > 100;
-SELECT * FROM orders WHERE total BETWEEN 100 AND 500;
-
--- Pattern matching
-SELECT * FROM users WHERE email LIKE '%@example.com';
-SELECT * FROM users WHERE name ILIKE 'john%';  -- case-insensitive
-
--- IN operator
-SELECT * FROM orders WHERE status IN ('pending', 'processing');
-
--- NULL checks
-SELECT * FROM users WHERE deleted_at IS NULL;
-SELECT * FROM users WHERE phone_number IS NOT NULL;
-
--- Logical operators
-SELECT * FROM products WHERE price > 100 AND stock > 0;
-SELECT * FROM users WHERE status = 'active' OR verified = true;
-SELECT * FROM products WHERE NOT (price > 1000);
-```
-
-### ORDER BY
-```sql
--- Ascending (default)
-SELECT * FROM users ORDER BY created_at;
-
--- Descending
-SELECT * FROM users ORDER BY created_at DESC;
-
--- Multiple columns
-SELECT * FROM orders ORDER BY status ASC, created_at DESC;
-
--- NULL handling
-SELECT * FROM users ORDER BY last_login NULLS FIRST;
-SELECT * FROM users ORDER BY last_login NULLS LAST;
-```
-
-### LIMIT and OFFSET
-```sql
--- Limit results
-SELECT * FROM users LIMIT 10;
-
--- Pagination
-SELECT * FROM users ORDER BY id LIMIT 10 OFFSET 20;
-
--- Alternative: FETCH
-SELECT * FROM users OFFSET 20 ROWS FETCH NEXT 10 ROWS ONLY;
-```
-
-## JOINs
-
-### INNER JOIN
-```sql
--- Match rows from both tables
-SELECT orders.id, orders.total, customers.name
-FROM orders
-INNER JOIN customers ON orders.customer_id = customers.id;
-
--- Short syntax
-SELECT o.id, o.total, c.name
-FROM orders o
-JOIN customers c ON o.customer_id = c.id;
-
--- Multiple joins
-SELECT o.id, c.name, p.name AS product
-FROM orders o
-JOIN customers c ON o.customer_id = c.id
-JOIN order_items oi ON oi.order_id = o.id
-JOIN products p ON oi.product_id = p.id;
-```
-
-### LEFT JOIN (LEFT OUTER JOIN)
-```sql
--- All rows from left table, matching rows from right
-SELECT c.name, o.id AS order_id
-FROM customers c
-LEFT JOIN orders o ON c.id = o.customer_id;
-
--- Find customers without orders
-SELECT c.name
-FROM customers c
-LEFT JOIN orders o ON c.id = o.customer_id
-WHERE o.id IS NULL;
-```
-
-### RIGHT JOIN (RIGHT OUTER JOIN)
-```sql
--- All rows from right table, matching rows from left
-SELECT c.name, o.id AS order_id
-FROM orders o
-RIGHT JOIN customers c ON o.customer_id = c.id;
-```
-
-### FULL OUTER JOIN
-```sql
--- All rows from both tables
-SELECT c.name, o.id AS order_id
-FROM customers c
-FULL OUTER JOIN orders o ON c.id = o.customer_id;
-```
-
-### CROSS JOIN
-```sql
--- Cartesian product (all combinations)
-SELECT c.name, p.name
-FROM colors c
-CROSS JOIN products p;
-```
-
-### Self Join
-```sql
--- Join table to itself
-SELECT e1.name AS employee, e2.name AS manager
-FROM employees e1
-LEFT JOIN employees e2 ON e1.manager_id = e2.id;
-```
-
-## Subqueries
-
-### Scalar Subquery
-```sql
--- Return single value
-SELECT name, salary,
-  (SELECT AVG(salary) FROM employees) AS avg_salary
-FROM employees;
-```
-
-### IN Subquery
-```sql
--- Match against set of values
-SELECT name FROM customers
-WHERE id IN (
-  SELECT customer_id FROM orders WHERE total > 1000
-);
-```
-
-### EXISTS Subquery
-```sql
--- Check if subquery returns any rows
-SELECT name FROM customers c
-WHERE EXISTS (
-  SELECT 1 FROM orders o WHERE o.customer_id = c.id
-);
-
--- NOT EXISTS
-SELECT name FROM customers c
-WHERE NOT EXISTS (
-  SELECT 1 FROM orders o WHERE o.customer_id = c.id
-);
-```
-
-### Correlated Subquery
-```sql
--- Subquery references outer query
-SELECT name, salary FROM employees e1
-WHERE salary > (
-  SELECT AVG(salary) FROM employees e2
-  WHERE e2.department_id = e1.department_id
-);
-```
-
-## Common Table Expressions (CTEs)
-
-### Simple CTE
-```sql
--- Named temporary result set
-WITH active_users AS (
-  SELECT id, name, email FROM users WHERE status = 'active'
-)
-SELECT * FROM active_users WHERE created_at > '2024-01-01';
-```
-
-### Multiple CTEs
-```sql
-WITH
-  active_customers AS (
-    SELECT id, name FROM customers WHERE active = true
-  ),
-  recent_orders AS (
-    SELECT customer_id, SUM(total) AS total_spent
-    FROM orders
-    WHERE order_date > CURRENT_DATE - INTERVAL '30 days'
-    GROUP BY customer_id
-  )
-SELECT c.name, COALESCE(o.total_spent, 0) AS spent
-FROM active_customers c
-LEFT JOIN recent_orders o ON c.id = o.customer_id;
-```
-
-### Recursive CTE
-```sql
--- Tree traversal, hierarchical data
-WITH RECURSIVE category_tree AS (
-  -- Base case: root categories
-  SELECT id, name, parent_id, 0 AS level
-  FROM categories
-  WHERE parent_id IS NULL
-
-  UNION ALL
-
-  -- Recursive case: child categories
-  SELECT c.id, c.name, c.parent_id, ct.level + 1
-  FROM categories c
-  JOIN category_tree ct ON c.parent_id = ct.id
-)
-SELECT * FROM category_tree ORDER BY level, name;
-
--- Employee hierarchy
-WITH RECURSIVE org_chart AS (
-  SELECT id, name, manager_id, 1 AS level
-  FROM employees
-  WHERE manager_id IS NULL
-
-  UNION ALL
-
-  SELECT e.id, e.name, e.manager_id, oc.level + 1
-  FROM employees e
-  JOIN org_chart oc ON e.manager_id = oc.id
-)
-SELECT * FROM org_chart;
-```
-
-## Aggregate Functions
-
-### Basic Aggregates
-```sql
--- COUNT, SUM, AVG, MIN, MAX
-SELECT
-  COUNT(*) AS total_orders,
-  SUM(total) AS total_revenue,
-  AVG(total) AS avg_order_value,
-  MIN(total) AS min_order,
-  MAX(total) AS max_order
-FROM orders;
-
--- COUNT variations
-SELECT COUNT(*) FROM users;              -- All rows
-SELECT COUNT(phone_number) FROM users;   -- Non-NULL values
-SELECT COUNT(DISTINCT status) FROM orders; -- Unique values
-```
-
-### GROUP BY
-```sql
--- Aggregate by groups
-SELECT status, COUNT(*) AS count
-FROM orders
-GROUP BY status;
-
--- Multiple grouping columns
-SELECT customer_id, status, COUNT(*) AS count
-FROM orders
-GROUP BY customer_id, status;
-
--- With aggregate functions
-SELECT customer_id,
-  COUNT(*) AS order_count,
-  SUM(total) AS total_spent,
-  AVG(total) AS avg_order
-FROM orders
-GROUP BY customer_id;
-```
-
-### HAVING
-```sql
--- Filter after aggregation
-SELECT customer_id, SUM(total) AS total_spent
-FROM orders
-GROUP BY customer_id
-HAVING SUM(total) > 1000;
-
--- Multiple conditions
-SELECT status, COUNT(*) AS count
-FROM orders
-GROUP BY status
-HAVING COUNT(*) > 10;
-```
-
-## Window Functions
-
-### ROW_NUMBER
-```sql
--- Assign unique number to each row
-SELECT id, name, salary,
-  ROW_NUMBER() OVER (ORDER BY salary DESC) AS rank
-FROM employees;
-
--- Partition by group
-SELECT id, department, salary,
-  ROW_NUMBER() OVER (PARTITION BY department ORDER BY salary DESC) AS dept_rank
-FROM employees;
-```
-
-### RANK / DENSE_RANK
-```sql
--- RANK: gaps in ranking for ties
--- DENSE_RANK: no gaps
-SELECT id, name, salary,
-  RANK() OVER (ORDER BY salary DESC) AS rank,
-  DENSE_RANK() OVER (ORDER BY salary DESC) AS dense_rank
-FROM employees;
-```
-
-### LAG / LEAD
-```sql
--- Access previous/next row
-SELECT date, revenue,
-  LAG(revenue) OVER (ORDER BY date) AS prev_revenue,
-  LEAD(revenue) OVER (ORDER BY date) AS next_revenue,
-  revenue - LAG(revenue) OVER (ORDER BY date) AS change
-FROM daily_sales;
-```
-
-### Running Totals
-```sql
--- Cumulative sum
-SELECT date, amount,
-  SUM(amount) OVER (ORDER BY date ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS running_total
-FROM transactions;
-
--- Simpler syntax
-SELECT date, amount,
-  SUM(amount) OVER (ORDER BY date) AS running_total
-FROM transactions;
-```
-
-### Moving Averages
-```sql
--- 7-day moving average
-SELECT date, value,
-  AVG(value) OVER (
-    ORDER BY date
-    ROWS BETWEEN 6 PRECEDING AND CURRENT ROW
-  ) AS moving_avg_7d
-FROM metrics;
-```
-
-## Advanced Patterns
-
-### CASE Expressions
-```sql
--- Simple CASE
-SELECT name,
-  CASE status
-    WHEN 'active' THEN 'Active User'
-    WHEN 'pending' THEN 'Pending Verification'
-    ELSE 'Inactive'
-  END AS status_label
-FROM users;
-
--- Searched CASE
-SELECT name, age,
-  CASE
-    WHEN age < 18 THEN 'Minor'
-    WHEN age BETWEEN 18 AND 65 THEN 'Adult'
-    ELSE 'Senior'
-  END AS age_group
-FROM users;
-```
-
-### COALESCE
-```sql
--- Return first non-NULL value
-SELECT name, COALESCE(phone_number, email, 'No contact') AS contact
-FROM users;
-```
-
-### NULLIF
-```sql
--- Return NULL if values equal
-SELECT name, NULLIF(status, 'deleted') AS active_status
-FROM users;
-```
-
-### Array Operations
-```sql
--- Array aggregate
-SELECT customer_id, ARRAY_AGG(product_id) AS products
-FROM order_items
-GROUP BY customer_id;
-
--- Unnest array
-SELECT unnest(ARRAY[1, 2, 3, 4, 5]);
-
--- Array contains
-SELECT * FROM products WHERE tags @> ARRAY['featured'];
-```
-
-### JSON Operations
-```sql
--- Query JSON/JSONB
-SELECT data->>'name' AS name FROM documents;
-SELECT data->'address'->>'city' AS city FROM documents;
-
--- Check key exists
-SELECT * FROM documents WHERE data ? 'email';
-
--- JSONB operators
-SELECT * FROM documents WHERE data @> '{"status": "active"}';
-
--- JSON aggregation
-SELECT json_agg(name) FROM users;
-SELECT json_object_agg(id, name) FROM users;
-```
-
-## Set Operations
-
-### UNION
-```sql
--- Combine results (removes duplicates)
-SELECT name FROM customers
-UNION
-SELECT name FROM suppliers;
-
--- Keep duplicates
-SELECT name FROM customers
-UNION ALL
-SELECT name FROM suppliers;
-```
-
-### INTERSECT
-```sql
--- Common rows
-SELECT email FROM users
-INTERSECT
-SELECT email FROM subscribers;
-```
-
-### EXCEPT
-```sql
--- Rows in first query but not second
-SELECT email FROM users
-EXCEPT
-SELECT email FROM unsubscribed;
-```
-
-## Best Practices
-
-1. **Use indexes** on WHERE, JOIN, ORDER BY columns
-2. **Avoid SELECT *** - specify needed columns
-3. **Use EXISTS** instead of IN for large subqueries
-4. **Filter early** - WHERE before JOIN when possible
-5. **Use CTEs** for readability over nested subqueries
-6. **Parameterize queries** - prevent SQL injection
-7. **Use window functions** instead of self-joins
-8. **Test with EXPLAIN** - analyze query plans
+# PostgreSQL SQL Queries
+
+SQL queries in PostgreSQL: SELECT, JOINs, subqueries, CTEs, window functions, and advanced patterns.
+
+## Basic SELECT
+
+### Simple Queries
+```sql
+-- Select all columns
+SELECT * FROM users;
+
+-- Select specific columns
+SELECT id, name, email FROM users;
+
+-- With alias
+SELECT name AS full_name, email AS contact_email FROM users;
+
+-- Distinct values
+SELECT DISTINCT status FROM orders;
+
+-- Count rows
+SELECT COUNT(*) FROM users;
+SELECT COUNT(DISTINCT status) FROM orders;
+```
+
+### WHERE Clause
+```sql
+-- Equality
+SELECT * FROM users WHERE status = 'active';
+
+-- Comparison
+SELECT * FROM products WHERE price > 100;
+SELECT * FROM orders WHERE total BETWEEN 100 AND 500;
+
+-- Pattern matching
+SELECT * FROM users WHERE email LIKE '%@example.com';
+SELECT * FROM users WHERE name ILIKE 'john%';  -- case-insensitive
+
+-- IN operator
+SELECT * FROM orders WHERE status IN ('pending', 'processing');
+
+-- NULL checks
+SELECT * FROM users WHERE deleted_at IS NULL;
+SELECT * FROM users WHERE phone_number IS NOT NULL;
+
+-- Logical operators
+SELECT * FROM products WHERE price > 100 AND stock > 0;
+SELECT * FROM users WHERE status = 'active' OR verified = true;
+SELECT * FROM products WHERE NOT (price > 1000);
+```
+
+### ORDER BY
+```sql
+-- Ascending (default)
+SELECT * FROM users ORDER BY created_at;
+
+-- Descending
+SELECT * FROM users ORDER BY created_at DESC;
+
+-- Multiple columns
+SELECT * FROM orders ORDER BY status ASC, created_at DESC;
+
+-- NULL handling
+SELECT * FROM users ORDER BY last_login NULLS FIRST;
+SELECT * FROM users ORDER BY last_login NULLS LAST;
+```
+
+### LIMIT and OFFSET
+```sql
+-- Limit results
+SELECT * FROM users LIMIT 10;
+
+-- Pagination
+SELECT * FROM users ORDER BY id LIMIT 10 OFFSET 20;
+
+-- Alternative: FETCH
+SELECT * FROM users OFFSET 20 ROWS FETCH NEXT 10 ROWS ONLY;
+```
+
+## JOINs
+
+### INNER JOIN
+```sql
+-- Match rows from both tables
+SELECT orders.id, orders.total, customers.name
+FROM orders
+INNER JOIN customers ON orders.customer_id = customers.id;
+
+-- Short syntax
+SELECT o.id, o.total, c.name
+FROM orders o
+JOIN customers c ON o.customer_id = c.id;
+
+-- Multiple joins
+SELECT o.id, c.name, p.name AS product
+FROM orders o
+JOIN customers c ON o.customer_id = c.id
+JOIN order_items oi ON oi.order_id = o.id
+JOIN products p ON oi.product_id = p.id;
+```
+
+### LEFT JOIN (LEFT OUTER JOIN)
+```sql
+-- All rows from left table, matching rows from right
+SELECT c.name, o.id AS order_id
+FROM customers c
+LEFT JOIN orders o ON c.id = o.customer_id;
+
+-- Find customers without orders
+SELECT c.name
+FROM customers c
+LEFT JOIN orders o ON c.id = o.customer_id
+WHERE o.id IS NULL;
+```
+
+### RIGHT JOIN (RIGHT OUTER JOIN)
+```sql
+-- All rows from right table, matching rows from left
+SELECT c.name, o.id AS order_id
+FROM orders o
+RIGHT JOIN customers c ON o.customer_id = c.id;
+```
+
+### FULL OUTER JOIN
+```sql
+-- All rows from both tables
+SELECT c.name, o.id AS order_id
+FROM customers c
+FULL OUTER JOIN orders o ON c.id = o.customer_id;
+```
+
+### CROSS JOIN
+```sql
+-- Cartesian product (all combinations)
+SELECT c.name, p.name
+FROM colors c
+CROSS JOIN products p;
+```
+
+### Self Join
+```sql
+-- Join table to itself
+SELECT e1.name AS employee, e2.name AS manager
+FROM employees e1
+LEFT JOIN employees e2 ON e1.manager_id = e2.id;
+```
+
+## Subqueries
+
+### Scalar Subquery
+```sql
+-- Return single value
+SELECT name, salary,
+  (SELECT AVG(salary) FROM employees) AS avg_salary
+FROM employees;
+```
+
+### IN Subquery
+```sql
+-- Match against set of values
+SELECT name FROM customers
+WHERE id IN (
+  SELECT customer_id FROM orders WHERE total > 1000
+);
+```
+
+### EXISTS Subquery
+```sql
+-- Check if subquery returns any rows
+SELECT name FROM customers c
+WHERE EXISTS (
+  SELECT 1 FROM orders o WHERE o.customer_id = c.id
+);
+
+-- NOT EXISTS
+SELECT name FROM customers c
+WHERE NOT EXISTS (
+  SELECT 1 FROM orders o WHERE o.customer_id = c.id
+);
+```
+
+### Correlated Subquery
+```sql
+-- Subquery references outer query
+SELECT name, salary FROM employees e1
+WHERE salary > (
+  SELECT AVG(salary) FROM employees e2
+  WHERE e2.department_id = e1.department_id
+);
+```
+
+## Common Table Expressions (CTEs)
+
+### Simple CTE
+```sql
+-- Named temporary result set
+WITH active_users AS (
+  SELECT id, name, email FROM users WHERE status = 'active'
+)
+SELECT * FROM active_users WHERE created_at > '2024-01-01';
+```
+
+### Multiple CTEs
+```sql
+WITH
+  active_customers AS (
+    SELECT id, name FROM customers WHERE active = true
+  ),
+  recent_orders AS (
+    SELECT customer_id, SUM(total) AS total_spent
+    FROM orders
+    WHERE order_date > CURRENT_DATE - INTERVAL '30 days'
+    GROUP BY customer_id
+  )
+SELECT c.name, COALESCE(o.total_spent, 0) AS spent
+FROM active_customers c
+LEFT JOIN recent_orders o ON c.id = o.customer_id;
+```
+
+### Recursive CTE
+```sql
+-- Tree traversal, hierarchical data
+WITH RECURSIVE category_tree AS (
+  -- Base case: root categories
+  SELECT id, name, parent_id, 0 AS level
+  FROM categories
+  WHERE parent_id IS NULL
+
+  UNION ALL
+
+  -- Recursive case: child categories
+  SELECT c.id, c.name, c.parent_id, ct.level + 1
+  FROM categories c
+  JOIN category_tree ct ON c.parent_id = ct.id
+)
+SELECT * FROM category_tree ORDER BY level, name;
+
+-- Employee hierarchy
+WITH RECURSIVE org_chart AS (
+  SELECT id, name, manager_id, 1 AS level
+  FROM employees
+  WHERE manager_id IS NULL
+
+  UNION ALL
+
+  SELECT e.id, e.name, e.manager_id, oc.level + 1
+  FROM employees e
+  JOIN org_chart oc ON e.manager_id = oc.id
+)
+SELECT * FROM org_chart;
+```
+
+## Aggregate Functions
+
+### Basic Aggregates
+```sql
+-- COUNT, SUM, AVG, MIN, MAX
+SELECT
+  COUNT(*) AS total_orders,
+  SUM(total) AS total_revenue,
+  AVG(total) AS avg_order_value,
+  MIN(total) AS min_order,
+  MAX(total) AS max_order
+FROM orders;
+
+-- COUNT variations
+SELECT COUNT(*) FROM users;              -- All rows
+SELECT COUNT(phone_number) FROM users;   -- Non-NULL values
+SELECT COUNT(DISTINCT status) FROM orders; -- Unique values
+```
+
+### GROUP BY
+```sql
+-- Aggregate by groups
+SELECT status, COUNT(*) AS count
+FROM orders
+GROUP BY status;
+
+-- Multiple grouping columns
+SELECT customer_id, status, COUNT(*) AS count
+FROM orders
+GROUP BY customer_id, status;
+
+-- With aggregate functions
+SELECT customer_id,
+  COUNT(*) AS order_count,
+  SUM(total) AS total_spent,
+  AVG(total) AS avg_order
+FROM orders
+GROUP BY customer_id;
+```
+
+### HAVING
+```sql
+-- Filter after aggregation
+SELECT customer_id, SUM(total) AS total_spent
+FROM orders
+GROUP BY customer_id
+HAVING SUM(total) > 1000;
+
+-- Multiple conditions
+SELECT status, COUNT(*) AS count
+FROM orders
+GROUP BY status
+HAVING COUNT(*) > 10;
+```
+
+## Window Functions
+
+### ROW_NUMBER
+```sql
+-- Assign unique number to each row
+SELECT id, name, salary,
+  ROW_NUMBER() OVER (ORDER BY salary DESC) AS rank
+FROM employees;
+
+-- Partition by group
+SELECT id, department, salary,
+  ROW_NUMBER() OVER (PARTITION BY department ORDER BY salary DESC) AS dept_rank
+FROM employees;
+```
+
+### RANK / DENSE_RANK
+```sql
+-- RANK: gaps in ranking for ties
+-- DENSE_RANK: no gaps
+SELECT id, name, salary,
+  RANK() OVER (ORDER BY salary DESC) AS rank,
+  DENSE_RANK() OVER (ORDER BY salary DESC) AS dense_rank
+FROM employees;
+```
+
+### LAG / LEAD
+```sql
+-- Access previous/next row
+SELECT date, revenue,
+  LAG(revenue) OVER (ORDER BY date) AS prev_revenue,
+  LEAD(revenue) OVER (ORDER BY date) AS next_revenue,
+  revenue - LAG(revenue) OVER (ORDER BY date) AS change
+FROM daily_sales;
+```
+
+### Running Totals
+```sql
+-- Cumulative sum
+SELECT date, amount,
+  SUM(amount) OVER (ORDER BY date ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS running_total
+FROM transactions;
+
+-- Simpler syntax
+SELECT date, amount,
+  SUM(amount) OVER (ORDER BY date) AS running_total
+FROM transactions;
+```
+
+### Moving Averages
+```sql
+-- 7-day moving average
+SELECT date, value,
+  AVG(value) OVER (
+    ORDER BY date
+    ROWS BETWEEN 6 PRECEDING AND CURRENT ROW
+  ) AS moving_avg_7d
+FROM metrics;
+```
+
+## Advanced Patterns
+
+### CASE Expressions
+```sql
+-- Simple CASE
+SELECT name,
+  CASE status
+    WHEN 'active' THEN 'Active User'
+    WHEN 'pending' THEN 'Pending Verification'
+    ELSE 'Inactive'
+  END AS status_label
+FROM users;
+
+-- Searched CASE
+SELECT name, age,
+  CASE
+    WHEN age < 18 THEN 'Minor'
+    WHEN age BETWEEN 18 AND 65 THEN 'Adult'
+    ELSE 'Senior'
+  END AS age_group
+FROM users;
+```
+
+### COALESCE
+```sql
+-- Return first non-NULL value
+SELECT name, COALESCE(phone_number, email, 'No contact') AS contact
+FROM users;
+```
+
+### NULLIF
+```sql
+-- Return NULL if values equal
+SELECT name, NULLIF(status, 'deleted') AS active_status
+FROM users;
+```
+
+### Array Operations
+```sql
+-- Array aggregate
+SELECT customer_id, ARRAY_AGG(product_id) AS products
+FROM order_items
+GROUP BY customer_id;
+
+-- Unnest array
+SELECT unnest(ARRAY[1, 2, 3, 4, 5]);
+
+-- Array contains
+SELECT * FROM products WHERE tags @> ARRAY['featured'];
+```
+
+### JSON Operations
+```sql
+-- Query JSON/JSONB
+SELECT data->>'name' AS name FROM documents;
+SELECT data->'address'->>'city' AS city FROM documents;
+
+-- Check key exists
+SELECT * FROM documents WHERE data ? 'email';
+
+-- JSONB operators
+SELECT * FROM documents WHERE data @> '{"status": "active"}';
+
+-- JSON aggregation
+SELECT json_agg(name) FROM users;
+SELECT json_object_agg(id, name) FROM users;
+```
+
+## Set Operations
+
+### UNION
+```sql
+-- Combine results (removes duplicates)
+SELECT name FROM customers
+UNION
+SELECT name FROM suppliers;
+
+-- Keep duplicates
+SELECT name FROM customers
+UNION ALL
+SELECT name FROM suppliers;
+```
+
+### INTERSECT
+```sql
+-- Common rows
+SELECT email FROM users
+INTERSECT
+SELECT email FROM subscribers;
+```
+
+### EXCEPT
+```sql
+-- Rows in first query but not second
+SELECT email FROM users
+EXCEPT
+SELECT email FROM unsubscribed;
+```
+
+## Best Practices
+
+1. **Use indexes** on WHERE, JOIN, ORDER BY columns
+2. **Avoid SELECT *** - specify needed columns
+3. **Use EXISTS** instead of IN for large subqueries
+4. **Filter early** - WHERE before JOIN when possible
+5. **Use CTEs** for readability over nested subqueries
+6. **Parameterize queries** - prevent SQL injection
+7. **Use window functions** instead of self-joins
+8. **Test with EXPLAIN** - analyze query plans