SQL para Analista Judiciário - TI: consultas, filtros, agregações e subconsultas

Este capítulo foca no uso operacional de SQL típico de prova: escrever consultas, prever resultados, identificar armadilhas (NULL, duplicidades, cardinalidade em JOIN) e entender a ordem lógica de execução. Os exemplos usam um cenário simplificado do Judiciário.

Base exemplificativa (contexto das questões)

Considere as tabelas abaixo (nomes e colunas típicos). Use-as para simular mentalmente resultados e resolver as baterias de questões.

PROCESSO(id_processo, numero, classe, assunto, id_vara, id_magistrado, dt_distribuicao, valor_causa)
PARTE(id_parte, nome, tipo_pessoa) -- 'F' ou 'J'
PROCESSO_PARTE(id_processo, id_parte, papel) -- 'AUTOR', 'REU', 'TERCEIRO'
VARA(id_vara, nome, comarca)
MAGISTRADO(id_magistrado, nome)
MOVIMENTACAO(id_mov, id_processo, dt_mov, codigo, descricao)
AUDIENCIA(id_aud, id_processo, dt_aud, tipo, status) -- status: 'MARCADA','REALIZADA','CANCELADA'
SENTENCA(id_sent, id_processo, dt_sent, resultado) -- 'PROCEDENTE','IMPROCEDENTE','EXTINTO'
USUARIO(id_usuario, login, perfil)
LOG_ACESSO(id_log, id_usuario, dt_evento, acao, id_processo)

Ordem lógica de execução (o que a banca cobra)

Uma armadilha recorrente é confundir a ordem em que você escreve com a ordem em que o SGBD avalia. A ordem lógica mais cobrada é:

• FROM (inclui JOIN e ON): monta o conjunto base.

• WHERE: filtra linhas (antes de agregação).

  Continue em nosso aplicativo

  Você poderá ouvir o audiobook com a tela desligada, ganhar gratuitamente o certificado deste curso e ainda ter acesso a outros 5.000 cursos online gratuitos.

  ou continue lendo abaixo...

  

  Baixar o aplicativo

• GROUP BY: forma grupos.

• HAVING: filtra grupos (após agregação).

• SELECT: projeta colunas/expressões (inclui agregações).

• DISTINCT: remove duplicidades do resultado projetado.

• ORDER BY: ordena o resultado final.

Em prova, isso explica por que você não pode usar alias do SELECT no WHERE (em geral), e por que HAVING é diferente de WHERE.

SELECT, projeção e expressões

Selecionando colunas e criando colunas calculadas

SELECT numero, classe, valor_causa, valor_causa * 0.1 AS custas_estimadas
FROM PROCESSO;

Armadilha: se valor_causa for NULL, a expressão vira NULL. Em provas, NULL “contamina” operações aritméticas.

DISTINCT (duplicidades visíveis e invisíveis)

DISTINCT atua sobre o conjunto inteiro de colunas selecionadas, não sobre uma coluna isolada (a menos que você selecione só ela).

-- Lista classes existentes (sem repetição)
SELECT DISTINCT classe
FROM PROCESSO;

-- Pode continuar repetindo numero se variar a classe (ou outra coluna)
SELECT DISTINCT classe, assunto
FROM PROCESSO;

Armadilha: usar DISTINCT para “consertar” duplicidade causada por JOIN costuma mascarar erro de cardinalidade.

WHERE: filtros, NULL e precedência lógica

Filtros básicos e intervalos

SELECT numero, dt_distribuicao
FROM PROCESSO
WHERE dt_distribuicao >= DATE '2024-01-01'
  AND dt_distribuicao <  DATE '2025-01-01';

IN, LIKE e armadilhas

SELECT numero, classe
FROM PROCESSO
WHERE classe IN ('MANDADO DE SEGURANCA', 'HABEAS CORPUS');

SELECT id_parte, nome
FROM PARTE
WHERE nome LIKE 'JOSE%';

Armadilha: LIKE pode ser case-sensitive dependendo de collation/configuração; em prova, foque na lógica do padrão.

NULL: IS NULL, IS NOT NULL e o “terceiro valor”

Comparações com NULL não retornam TRUE/FALSE, mas “desconhecido”, o que faz a linha ser descartada no WHERE.

-- ERRADO para achar nulos
SELECT * FROM SENTENCA WHERE resultado = NULL;

-- CERTO
SELECT * FROM SENTENCA WHERE resultado IS NULL;

-- Exemplo de armadilha
SELECT * FROM PROCESSO
WHERE valor_causa > 10000;

Se valor_causa for NULL, a condição não é verdadeira e a linha não aparece.

Precedência: AND antes de OR

-- Sem parênteses, AND é avaliado antes de OR
SELECT numero
FROM PROCESSO
WHERE classe = 'ACAO CIVIL PUBLICA'
   OR classe = 'MANDADO DE SEGURANCA' AND valor_causa > 50000;

Interpretação lógica: classe='ACAO CIVIL PUBLICA' OR (classe='MANDADO...' AND valor_causa>50000). Em prova, a diferença de parênteses muda o conjunto retornado.

ORDER BY: ordenação e NULLs

SELECT numero, dt_distribuicao, valor_causa
FROM PROCESSO
ORDER BY dt_distribuicao DESC, valor_causa ASC;

Armadilha: posição de NULL na ordenação varia por SGBD (NULLS FIRST/LAST pode existir). Se a questão mencionar explicitamente, use; se não, foque na ordem relativa dos não nulos.

Agregações: COUNT, SUM, AVG, MIN, MAX

GROUP BY e agregação básica

SELECT classe, COUNT(*) AS qtd
FROM PROCESSO
GROUP BY classe;

Armadilha: toda coluna no SELECT que não é agregada deve estar no GROUP BY (regra geral cobrada).

COUNT(*) vs COUNT(coluna)

-- Conta linhas (inclui linhas com valor_causa NULL)
SELECT COUNT(*) FROM PROCESSO;

-- Conta apenas linhas onde valor_causa NÃO é NULL
SELECT COUNT(valor_causa) FROM PROCESSO;

Em prova, isso é uma das diferenças mais exploradas.

HAVING (filtro pós-agrupamento)

SELECT id_vara, COUNT(*) AS qtd_processos
FROM PROCESSO
GROUP BY id_vara
HAVING COUNT(*) >= 100;

Armadilha: tentar usar agregação no WHERE (em geral inválido). O filtro de grupos é no HAVING.

Agregação com condição (padrão de prova)

Quando não há FILTER (dependente de SGBD), usa-se SUM(CASE WHEN ... THEN 1 ELSE 0 END).

SELECT id_vara,
       COUNT(*) AS total,
       SUM(CASE WHEN valor_causa > 100000 THEN 1 ELSE 0 END) AS acima_100k
FROM PROCESSO
GROUP BY id_vara;

JOINs: INNER, LEFT, RIGHT, FULL e cardinalidade

INNER JOIN (interseção)

SELECT p.numero, v.nome AS vara
FROM PROCESSO p
INNER JOIN VARA v ON v.id_vara = p.id_vara;

Retorna apenas processos com vara correspondente.

LEFT JOIN (preserva a tabela da esquerda)

SELECT v.nome AS vara, p.numero
FROM VARA v
LEFT JOIN PROCESSO p ON p.id_vara = v.id_vara
ORDER BY v.nome;

Mostra varas mesmo sem processos (colunas de p ficam NULL).

Armadilha clássica: filtro no WHERE “anula” o LEFT JOIN

Se você filtra uma coluna da tabela da direita no WHERE, você elimina as linhas onde ela é NULL, transformando o efeito em INNER JOIN.

-- Armadilha: perde varas sem processos
SELECT v.nome, p.numero
FROM VARA v
LEFT JOIN PROCESSO p ON p.id_vara = v.id_vara
WHERE p.dt_distribuicao >= DATE '2024-01-01';

-- Correto (preserva varas sem processos): filtra no ON
SELECT v.nome, p.numero
FROM VARA v
LEFT JOIN PROCESSO p
  ON p.id_vara = v.id_vara
 AND p.dt_distribuicao >= DATE '2024-01-01';

RIGHT JOIN e FULL JOIN

RIGHT JOIN é simétrico ao LEFT (preserva a tabela da direita). Muitas bancas cobram que você saiba reescrever RIGHT como LEFT invertendo a ordem.

-- RIGHT JOIN
SELECT p.numero, v.nome
FROM PROCESSO p
RIGHT JOIN VARA v ON v.id_vara = p.id_vara;

-- Equivalente com LEFT JOIN
SELECT p.numero, v.nome
FROM VARA v
LEFT JOIN PROCESSO p ON p.id_vara = v.id_vara;

FULL JOIN retorna correspondências e também não correspondências de ambos os lados (onde não casar, vem NULL do outro lado).

SELECT p.numero, v.nome
FROM PROCESSO p
FULL JOIN VARA v ON v.id_vara = p.id_vara;

Cardinalidade e duplicidades em JOIN (1:N e N:N)

Quando você junta PROCESSO com PROCESSO_PARTE, um processo pode aparecer várias vezes (uma por parte). Isso é esperado, mas vira armadilha quando você quer “um processo por linha”.

-- Um processo pode repetir para cada parte
SELECT p.numero, pp.papel, pa.nome
FROM PROCESSO p
JOIN PROCESSO_PARTE pp ON pp.id_processo = p.id_processo
JOIN PARTE pa ON pa.id_parte = pp.id_parte;

Armadilha: contar processos após esse JOIN com COUNT(*) conta linhas do relacionamento, não processos. Para contar processos distintos:

SELECT COUNT(DISTINCT p.id_processo) AS qtd_processos
FROM PROCESSO p
JOIN PROCESSO_PARTE pp ON pp.id_processo = p.id_processo;

UNION e UNION ALL

UNION remove duplicidades entre os conjuntos; UNION ALL mantém tudo (mais rápido e sem deduplicação).

-- Partes que aparecem como AUTOR ou REU (sem repetição)
SELECT id_parte FROM PROCESSO_PARTE WHERE papel = 'AUTOR'
UNION
SELECT id_parte FROM PROCESSO_PARTE WHERE papel = 'REU';

-- Mantém duplicidades (ex.: mesma parte em vários processos)
SELECT id_parte FROM PROCESSO_PARTE WHERE papel = 'AUTOR'
UNION ALL
SELECT id_parte FROM PROCESSO_PARTE WHERE papel = 'REU';

Armadilha: ORDER BY em UNION normalmente só pode aparecer no final (ordenando o resultado combinado), e as consultas precisam ter o mesmo número de colunas e tipos compatíveis.

Subconsultas: IN/EXISTS, escalares e correlacionadas

Subconsulta com IN (cuidado com NULL)

-- Processos que têm sentença
SELECT p.numero
FROM PROCESSO p
WHERE p.id_processo IN (SELECT s.id_processo FROM SENTENCA s);

Armadilha: se a subconsulta retornar NULL (por exemplo, coluna nullable), IN pode produzir efeitos contraintuitivos em algumas situações. Em prova, a alternativa mais robusta costuma ser EXISTS.

EXISTS (semântica de “existe pelo menos um”)

SELECT p.numero
FROM PROCESSO p
WHERE EXISTS (
  SELECT 1
  FROM MOVIMENTACAO m
  WHERE m.id_processo = p.id_processo
    AND m.codigo = 123
);

EXISTS para assim que encontra uma linha que satisfaça a condição (conceito lógico importante).

Subconsulta escalar (retorna um valor)

SELECT p.numero,
       (SELECT MAX(m.dt_mov)
        FROM MOVIMENTACAO m
        WHERE m.id_processo = p.id_processo) AS ultima_mov
FROM PROCESSO p;

Armadilha: se a subconsulta escalar retornar mais de uma linha, dá erro. Por isso, usa-se agregação (MAX/MIN) ou critérios que garantam unicidade.

Subconsulta correlacionada (padrão de prova)

É correlacionada quando referencia a linha da consulta externa.

-- Processos cujo valor_causa é maior que a média da própria vara
SELECT p.numero, p.id_vara, p.valor_causa
FROM PROCESSO p
WHERE p.valor_causa > (
  SELECT AVG(p2.valor_causa)
  FROM PROCESSO p2
  WHERE p2.id_vara = p.id_vara
);

Armadilha: se houver NULL em valor_causa, AVG ignora NULL (na maioria dos SGBDs), mas a comparação p.valor_causa > ... exclui linhas onde p.valor_causa é NULL.

NOT EXISTS (anti-join) e a armadilha do NOT IN

NOT IN com subconsulta que retorna NULL pode eliminar tudo (porque a comparação vira “desconhecida”). Em prova, NOT EXISTS é a forma mais segura.

-- Processos sem sentença
SELECT p.numero
FROM PROCESSO p
WHERE NOT EXISTS (
  SELECT 1
  FROM SENTENCA s
  WHERE s.id_processo = p.id_processo
);

Leitura de “plano lógico” e interpretação de resultados

Como simular o resultado de uma consulta em prova (passo a passo)

• 1) FROM/JOIN: determine a cardinalidade esperada. Ex.: PROCESSO (1) com PROCESSO_PARTE (N) multiplica linhas.

• 2) ON: aplique as condições de junção e filtros no ON (especialmente em LEFT/RIGHT).

• 3) WHERE: elimine linhas. Lembre: condições com NULL não passam.

• 4) GROUP BY: forme grupos e calcule agregações.

• 5) HAVING: elimine grupos que não atendem ao critério.

• 6) SELECT/DISTINCT: projete colunas e remova duplicidades se houver DISTINCT.

• 7) ORDER BY: ordene o resultado final.

Exemplo guiado: duplicidade por JOIN e correção

Objetivo: listar processos e a quantidade de réus em cada um.

-- Errado: mistura colunas sem agrupar corretamente
SELECT p.numero, pa.nome, COUNT(*)
FROM PROCESSO p
JOIN PROCESSO_PARTE pp ON pp.id_processo = p.id_processo
JOIN PARTE pa ON pa.id_parte = pp.id_parte
WHERE pp.papel = 'REU'
GROUP BY p.numero;

Problema: pa.nome não está no GROUP BY nem é agregada (em geral inválido). Correção:

SELECT p.numero, COUNT(*) AS qtd_reus
FROM PROCESSO p
JOIN PROCESSO_PARTE pp ON pp.id_processo = p.id_processo
WHERE pp.papel = 'REU'
GROUP BY p.numero;

Se a banca quiser “processos sem réu”, use LEFT JOIN e filtre no ON:

SELECT p.numero, COUNT(pp.id_parte) AS qtd_reus
FROM PROCESSO p
LEFT JOIN PROCESSO_PARTE pp
  ON pp.id_processo = p.id_processo
 AND pp.papel = 'REU'
GROUP BY p.numero;

Armadilha: em LEFT JOIN, COUNT(*) contaria 1 mesmo sem réu (porque a linha do processo existe). Use COUNT(pp.id_parte) para contar apenas quando há correspondência.

Bateria de questões (estilo concurso) com gabarito

Questões 1 a 6: SELECT/WHERE/ORDER BY/DISTINCT/NULL

Q1. Qual consulta lista os números de processos distribuídos em 2024 (inclusive) e ordena do mais recente para o mais antigo?

A) SELECT numero FROM PROCESSO WHERE dt_distribuicao BETWEEN '2024-01-01' AND '2024-12-31' ORDER BY dt_distribuicao;
B) SELECT numero FROM PROCESSO WHERE dt_distribuicao >= DATE '2024-01-01' AND dt_distribuicao < DATE '2025-01-01' ORDER BY dt_distribuicao DESC;
C) SELECT numero FROM PROCESSO WHERE dt_distribuicao > DATE '2024-01-01' AND dt_distribuicao <= DATE '2024-12-31' ORDER BY dt_distribuicao DESC;
D) SELECT numero FROM PROCESSO ORDER BY dt_distribuicao DESC WHERE dt_distribuicao >= DATE '2024-01-01';

Gabarito: B. (D está com ordem sintática inválida; A ordena asc; C exclui 01/01 e inclui 31/12, mas depende de horário; B é intervalo semiaberto robusto.)

Q2. Para retornar processos cujo valor_causa é desconhecido, a condição correta é:

A) valor_causa = NULL
B) valor_causa <> NULL
C) valor_causa IS NULL
D) valor_causa IN (NULL)

Gabarito: C.

Q3. Considere: SELECT DISTINCT classe, assunto FROM PROCESSO. O DISTINCT remove duplicidade de:

A) apenas classe
B) apenas assunto
C) do par (classe, assunto)
D) de todas as colunas da tabela PROCESSO

Gabarito: C.

Q4. Qual expressão conta todas as linhas da tabela PROCESSO, inclusive com valor_causa NULL?

A) COUNT(valor_causa)
B) COUNT(*)
C) COUNT(DISTINCT valor_causa)
D) SUM(valor_causa)

Gabarito: B.

Q5. Qual consulta pode retornar linhas inesperadas por precedência de operadores?

A) WHERE classe='X' AND assunto='Y'
B) WHERE classe='X' OR assunto='Y' AND valor_causa>0
C) WHERE NOT (classe='X')
D) WHERE valor_causa BETWEEN 1 AND 10

Gabarito: B (AND antes de OR; precisa parênteses para intenção).

Q6. Qual alternativa descreve corretamente o efeito de ORDER BY?

A) Filtra linhas antes do SELECT
B) Ordena o resultado final após DISTINCT
C) Agrupa linhas por colunas
D) Remove duplicidades automaticamente

Gabarito: B.

Questões 7 a 12: GROUP BY/HAVING e armadilhas

Q7. Liste varas com mais de 200 processos. Qual cláusula deve conter a condição COUNT(*) > 200?

A) WHERE
B) HAVING
C) ON
D) ORDER BY

Gabarito: B.

Q8. Qual consulta retorna a quantidade de processos por vara, incluindo varas sem processos?

A) SELECT v.id_vara, COUNT(*) FROM VARA v JOIN PROCESSO p ON p.id_vara=v.id_vara GROUP BY v.id_vara;
B) SELECT v.id_vara, COUNT(p.id_processo) FROM VARA v LEFT JOIN PROCESSO p ON p.id_vara=v.id_vara GROUP BY v.id_vara;
C) SELECT v.id_vara, COUNT(*) FROM VARA v LEFT JOIN PROCESSO p ON p.id_vara=v.id_vara WHERE p.id_processo IS NOT NULL GROUP BY v.id_vara;
D) SELECT v.id_vara, COUNT(DISTINCT v.id_vara) FROM VARA v GROUP BY v.id_vara;

Gabarito: B. (A exclui varas sem processo; C volta a excluir por causa do WHERE; D sempre dá 1 por vara.)

Q9. Em LEFT JOIN, para contar correspondências da tabela da direita sem inflar contagem quando não há match, usa-se:

A) COUNT(*)
B) COUNT(1)
C) COUNT(coluna_da_direita)
D) SUM(*)

Gabarito: C.

Q10. Qual consulta está semanticamente correta para contar processos distintos após juntar com partes?

A) SELECT COUNT(*) FROM PROCESSO p JOIN PROCESSO_PARTE pp ON pp.id_processo=p.id_processo;
B) SELECT COUNT(DISTINCT p.id_processo) FROM PROCESSO p JOIN PROCESSO_PARTE pp ON pp.id_processo=p.id_processo;
C) SELECT DISTINCT COUNT(p.id_processo) FROM PROCESSO p JOIN PROCESSO_PARTE pp ON pp.id_processo=p.id_processo;
D) SELECT COUNT(p.id_processo) FROM PROCESSO p JOIN PROCESSO_PARTE pp ON pp.id_processo=p.id_processo GROUP BY pp.id_parte;

Gabarito: B.

Q11. Para obter a média de valor_causa por classe, ignorando valores NULL (comportamento padrão), usa-se:

A) AVG(valor_causa)
B) AVG(COALESCE(valor_causa,0))
C) SUM(valor_causa)/COUNT(*)
D) SUM(valor_causa)/COUNT(valor_causa)+1

Gabarito: A. (B altera semântica; C inclui linhas NULL no denominador; D é incorreto.)

Q12. Qual consulta filtra corretamente processos de 2024 e depois agrupa por classe?

A) SELECT classe, COUNT(*) FROM PROCESSO GROUP BY classe WHERE dt_distribuicao>=DATE '2024-01-01';
B) SELECT classe, COUNT(*) FROM PROCESSO WHERE dt_distribuicao>=DATE '2024-01-01' GROUP BY classe;
C) SELECT classe, COUNT(*) FROM PROCESSO HAVING dt_distribuicao>=DATE '2024-01-01' GROUP BY classe;
D) SELECT classe, COUNT(*) FROM PROCESSO GROUP BY classe ORDER BY dt_distribuicao;

Gabarito: B.

Questões 13 a 18: JOINs, UNION e subconsultas correlacionadas

Q13. Você precisa listar todas as varas e, quando existir, o número do processo. Qual JOIN é adequado?

A) INNER JOIN
B) LEFT JOIN com VARA à esquerda
C) RIGHT JOIN com VARA à esquerda
D) CROSS JOIN

Gabarito: B.

Q14. Qual alternativa descreve corretamente o efeito de colocar um filtro de data no WHERE após um LEFT JOIN?

A) Mantém linhas sem correspondência e filtra apenas as correspondentes
B) Pode eliminar linhas sem correspondência, aproximando-se de um INNER JOIN
C) Transforma o LEFT JOIN em FULL JOIN
D) Não tem efeito

Gabarito: B.

Q15. Para combinar listas de id_parte de autores e réus sem remover duplicidades, usa-se:

A) UNION
B) UNION ALL
C) JOIN
D) DISTINCT

Gabarito: B.

Q16. Qual consulta encontra processos sem sentença de forma robusta contra NULL?

A) WHERE id_processo NOT IN (SELECT id_processo FROM SENTENCA)
B) WHERE NOT EXISTS (SELECT 1 FROM SENTENCA s WHERE s.id_processo = p.id_processo)
C) WHERE id_processo <> (SELECT id_processo FROM SENTENCA)
D) WHERE id_processo IN (SELECT NULL FROM SENTENCA)

Gabarito: B.

Q17. Qual é uma subconsulta correlacionada?

A) SELECT * FROM PROCESSO WHERE id_vara IN (SELECT id_vara FROM VARA)
B) SELECT * FROM PROCESSO p WHERE valor_causa > (SELECT AVG(valor_causa) FROM PROCESSO)
C) SELECT * FROM PROCESSO p WHERE valor_causa > (SELECT AVG(p2.valor_causa) FROM PROCESSO p2 WHERE p2.id_vara = p.id_vara)
D) SELECT * FROM PROCESSO WHERE EXISTS (SELECT 1)

Gabarito: C.

Q18. Ao juntar PROCESSO (1) com MOVIMENTACAO (N), qual efeito esperado no número de linhas?

A) Diminui sempre
B) Mantém sempre igual
C) Pode aumentar, repetindo processos para cada movimentação
D) Vira sempre 1 linha por processo por causa do JOIN

Gabarito: C.

Mini-roteiros práticos (treino rápido)

Roteiro 1: “prever resultado” com JOIN e DISTINCT

• Escreva uma consulta que liste p.numero e pa.nome para autores.

• Observe que um processo com dois autores aparece duas vezes.

• Se a questão pedir “processos que têm pelo menos um autor”, reescreva usando EXISTS ou COUNT(DISTINCT p.id_processo), em vez de DISTINCT p.numero sem critério.

-- Pelo menos um autor (sem multiplicar linhas)
SELECT p.numero
FROM PROCESSO p
WHERE EXISTS (
  SELECT 1
  FROM PROCESSO_PARTE pp
  WHERE pp.id_processo = p.id_processo
    AND pp.papel = 'AUTOR'
);

Roteiro 2: “último evento” por processo (subconsulta escalar)

• Identifique a tabela de eventos (MOVIMENTACAO).

• Use MAX(dt_mov) por processo.

• Projete como coluna calculada no SELECT.

SELECT p.numero,
       (SELECT MAX(m.dt_mov)
        FROM MOVIMENTACAO m
        WHERE m.id_processo = p.id_processo) AS ultima_mov
FROM PROCESSO p
ORDER BY ultima_mov DESC;

Roteiro 3: “contagem condicional” por vara (agregação com CASE)

• Defina o critério (ex.: audiências canceladas).

• Use SUM(CASE ...) para contar apenas as que atendem.

• Garanta que o JOIN não multiplique indevidamente (se houver outras tabelas, agregue antes ou use subconsulta).

SELECT p.id_vara,
       COUNT(DISTINCT p.id_processo) AS total_processos,
       SUM(CASE WHEN a.status = 'CANCELADA' THEN 1 ELSE 0 END) AS aud_canceladas
FROM PROCESSO p
LEFT JOIN AUDIENCIA a ON a.id_processo = p.id_processo
GROUP BY p.id_vara;