SELECT nome, total,
  RANK()       OVER (ORDER BY total DESC) AS rank,
  DENSE_RANK() OVER (ORDER BY total DESC) AS dense
FROM pedidos;

SELECT mes, receita,
  LAG(receita) OVER (ORDER BY mes) AS mes_anterior,
  receita - LAG(receita) OVER (ORDER BY mes) AS variacao
FROM receita_mensal;

SELECT data, valor,
  SUM(valor) OVER (ORDER BY data
    ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS acumulado
FROM movimentacoes;

SELECT nome, total,
  NTILE(4) OVER (ORDER BY total DESC) AS quartil
FROM clientes_gasto;

SELECT cidade, nome, total,
  FIRST_VALUE(nome) OVER (
    PARTITION BY cidade ORDER BY total DESC) AS maior_comprador
FROM pedidos;

WITH faturamento AS (
  SELECT cidade, SUM(total) AS total FROM pedidos GROUP BY cidade
)
SELECT * FROM faturamento WHERE total > 10000;

WITH RECURSIVE subordinados AS (
  SELECT id, nome, gerente_id FROM funcionarios WHERE id = 1
  UNION ALL
  SELECT f.id, f.nome, f.gerente_id
  FROM funcionarios f
  JOIN subordinados s ON f.gerente_id = s.id
)
SELECT * FROM subordinados;

SELECT produto,
  SUM(CASE WHEN mes = 1 THEN qtd END) AS jan,
  SUM(CASE WHEN mes = 2 THEN qtd END) AS fev,
  SUM(CASE WHEN mes = 3 THEN qtd END) AS mar
FROM vendas
GROUP BY produto;

SELECT produto, 'jan' AS mes, jan AS qtd FROM vendas_wide
UNION ALL
SELECT produto, 'fev', fev FROM vendas_wide
UNION ALL
SELECT produto, 'mar', mar FROM vendas_wide;

-- PostgreSQL / SQLite
INSERT INTO estoque (produto_id, qtd) VALUES (10, 5)
ON CONFLICT (produto_id)
DO UPDATE SET qtd = estoque.qtd + EXCLUDED.qtd;

INSERT INTO estoque (produto_id, qtd) VALUES (10, 5)
ON DUPLICATE KEY UPDATE qtd = qtd + VALUES(qtd);

-- A ordem importa: filtra por cliente_id e ordena por data
CREATE INDEX idx_ped_cli_data ON pedidos(cliente_id, data);

-- Covering: inclui colunas do SELECT (PostgreSQL)
CREATE INDEX idx_cover ON pedidos(cliente_id) INCLUDE (total);

EXPLAIN ANALYZE
SELECT * FROM pedidos WHERE cliente_id = 42;
-- Procure por 'Seq Scan' (ruim em tabela grande) vs 'Index Scan' (bom)

-- RUIM: função na coluna impede o índice
WHERE YEAR(data) = 2024

-- BOM: usa o índice em 'data'
WHERE data >= '2024-01-01' AND data < '2025-01-01'

CREATE MATERIALIZED VIEW mv_dashboard AS
SELECT cidade, SUM(total) AS total FROM pedidos GROUP BY cidade;

REFRESH MATERIALIZED VIEW mv_dashboard;

CREATE PROCEDURE dar_desconto(IN pid INT, IN pct DECIMAL)
BEGIN
  UPDATE produtos SET preco = preco * (1 - pct/100) WHERE id = pid;
END;

CALL dar_desconto(10, 15);

CREATE FUNCTION preco_com_iva(preco DECIMAL)
RETURNS DECIMAL
RETURN preco * 1.23;

SELECT nome, preco_com_iva(preco) FROM produtos;

CREATE TRIGGER trg_log_preco
AFTER UPDATE ON produtos
FOR EACH ROW
INSERT INTO log_precos (produto_id, preco_antigo, preco_novo)
VALUES (OLD.id, OLD.preco, NEW.preco);

-- READ COMMITTED (padrão em muitos bancos), REPEATABLE READ, SERIALIZABLE
SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
BEGIN;
  -- leituras consistentes, sem 'phantom reads'
COMMIT;

-- Bloqueia as linhas até o COMMIT (evita corrida)
BEGIN;
  SELECT * FROM contas WHERE id = 1 FOR UPDATE;
  UPDATE contas SET saldo = saldo - 100 WHERE id = 1;
COMMIT;

CREATE TABLE pedidos (id BIGINT, data DATE, total DECIMAL)
PARTITION BY RANGE (data);

CREATE TABLE pedidos_2024 PARTITION OF pedidos
FOR VALUES FROM ('2024-01-01') TO ('2025-01-01');

-- RUIM (repete cliente em cada pedido):
-- pedidos(id, cliente_nome, cliente_email, total)

-- BOM (3NF): separa em duas tabelas ligadas por FK
-- clientes(id, nome, email)
-- pedidos(id, cliente_id, total)

-- Guarda o total já calculado para não recalcular a cada leitura
ALTER TABLE clientes ADD COLUMN total_gasto DECIMAL(12,2) DEFAULT 0;
-- (mantido por trigger ou job)

-- Só pedidos em aberto (PostgreSQL)
CREATE INDEX idx_abertos ON pedidos(cliente_id) WHERE status = 'aberto';

SELECT cidade, categoria, SUM(total)
FROM pedidos
GROUP BY ROLLUP (cidade, categoria);

SELECT c.nome, p.*
FROM clientes c
CROSS JOIN LATERAL (
  SELECT * FROM pedidos p
  WHERE p.cliente_id = c.id ORDER BY data DESC LIMIT 3
) p; -- 3 últimos pedidos de cada cliente

-- PostgreSQL
SELECT dados->>'email' AS email
FROM eventos
WHERE dados->>'tipo' = 'login';

-- Índice em campo JSON
CREATE INDEX idx_tipo ON eventos ((dados->>'tipo'));

-- PostgreSQL
SELECT * FROM artigos
WHERE to_tsvector('portuguese', corpo) @@ to_tsquery('portuguese', 'banco & dados');

-- Evite: SELECT * (traz colunas demais, quebra covering index)
-- Evite: consultar dentro de loop no app (N+1) -> use JOIN
-- Evite: WHERE LOWER(email) = ... -> use coluna/índice apropriado

-- Prefira EXISTS para 'tem pelo menos um'
SELECT c.* FROM clientes c
WHERE EXISTS (SELECT 1 FROM pedidos p WHERE p.cliente_id = c.id);

-- NOT IN quebra se a subconsulta tiver NULL -> use NOT EXISTS

CREATE TEMP TABLE tmp_top AS
SELECT cliente_id, SUM(total) AS total
FROM pedidos GROUP BY cliente_id;

CREATE INDEX ON tmp_top(total);
SELECT * FROM tmp_top ORDER BY total DESC LIMIT 10;

-- LENTO em páginas altas:
SELECT * FROM pedidos ORDER BY id LIMIT 20 OFFSET 100000;

-- RÁPIDO (keyset):
SELECT * FROM pedidos WHERE id > 100000 ORDER BY id LIMIT 20;

-- Apaga 10 mil por vez, em loop no app
DELETE FROM logs
WHERE id IN (
  SELECT id FROM logs WHERE criado_em < '2023-01-01' LIMIT 10000
);

-- PERIGOSO (injeção!):
-- "SELECT * FROM users WHERE email = '" + input + "'"

-- SEGURO (placeholder / prepared statement):
SELECT * FROM users WHERE email = ?;   -- valor passado à parte

-- Se precisar de coluna/tabela dinâmica, use whitelist:
-- if (col not in ['nome','email']) throw;
-- e SEMPRE parametrize os VALORES, nunca o input direto.

GRANT SELECT, INSERT ON pedidos TO app_user;
REVOKE DELETE ON pedidos FROM app_user;

-- PostgreSQL
-- pg_dump -Fc meubanco > backup.dump
-- pg_restore -d meubanco backup.dump

-- Point-in-time recovery com WAL para restaurar até um instante

-- Réplica de leitura: app manda SELECTs para o replica, writes para o primary.
-- Sharding: cliente_id % 4 decide em qual shard a linha vive.
-- (configuração de infraestrutura, não um comando único)