0Pricing
SQL Interview Prep · Aula

Percorrendo um organograma

Percorra uma hierarquia funcionário-gerente até qualquer profundidade.

Percorrendo um organograma é uma aula grátis de SQL Interview Prep no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de SQL Interview Prep, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de SQL Interview Prep inclui 4 aulas no total.

A pergunta sobre o organograma

"Dada uma tabela employees com id, name e manager_id, liste todas as pessoas subordinadas a um gerente específico, em qualquer profundidade." Essa é uma das perguntas mais comuns de entrevistas sobre CTEs recursivas.

A tabela é autorreferente: manager_id aponta para o id de outra linha. Nesta lição, você percorrerá a estrutura para baixo (subordinados) e para cima (cadeia de comando).

A tabela de exemplo

Imagine estes dados. O CEO tem o gerente NULL. Todas as outras pessoas se reportam a alguém acima na cadeia.

  • 1 Ada (gerente NULL)
  • 2 Ben (gerente 1)
  • 3 Cleo (gerente 1)
  • 4 Dan (gerente 2)
  • 5 Eve (gerente 4)

Assim, a profundidade é: Ada → Ben → Dan → Eve. Tenha isso em mente enquanto percorremos a estrutura.

CREATE TABLE employees (
    id INT PRIMARY KEY,
    name VARCHAR(50),
    manager_id INT REFERENCES employees(id)
);

Percorrendo para baixo a partir de um gerente

Para listar todos os subordinados de um gerente escolhido, a âncora seleciona esse gerente (ou seus subordinados diretos), e o membro recursivo segue manager_id para baixo.

Aqui, começamos por Ben (identificador 2) e coletamos todas as pessoas abaixo dele.

WITH RECURSIVE subtree AS (
    SELECT id, name, manager_id, 1 AS depth
    FROM employees WHERE id = 2
    UNION ALL
    SELECT e.id, e.name, e.manager_id, s.depth + 1
    FROM employees e
    JOIN subtree s ON e.manager_id = s.id
)
SELECT name, depth FROM subtree ORDER BY depth;

Lendo a saída

A consulta acima retorna Ben na profundidade 1, Dan na profundidade 2 e Eve na profundidade 3. A âncora inicializou Ben; a primeira iteração encontrou Dan (cujo gerente é Ben); a segunda iteração encontrou Eve (cujo gerente é Dan); a terceira iteração não encontrou ninguém, então a recursão parou.

Se o entrevistador perguntar "a quantos níveis de profundidade Eve está abaixo de Ben?", a coluna depth responde diretamente: 3 menos 1 é igual a 2 níveis.

Subindo até o CEO

A pergunta inversa é igualmente comum: "Mostre toda a cadeia de comando de Eve até o CEO." Inverta a direção da junção — agora o membro recursivo segue o manager_id da linha atual até o elemento pai.

WITH RECURSIVE chain AS (
    SELECT id, name, manager_id, 1 AS lvl
    FROM employees WHERE id = 5
    UNION ALL
    SELECT e.id, e.name, e.manager_id, c.lvl + 1
    FROM employees e
    JOIN chain c ON e.id = c.manager_id
)
SELECT name, lvl FROM chain ORDER BY lvl;

Descida versus subida: o JOIN se inverte

A única diferença estrutural entre percorrer para baixo e percorrer para cima é a condição da junção:

  • Para baixo (encontrar subordinados): e.manager_id = cte.id — corresponde aos funcionários cujo gerente é uma linha que já temos.
  • Para cima (encontrar gerentes): e.id = cte.manager_id — corresponde ao funcionário cujo identificador é o gerente da nossa linha atual.

Conseguir explicar essa inversão com clareza impressiona os entrevistadores.

Construindo uma árvore recuada

Uma resposta bem elaborada formata a saída como uma árvore recuada, usando depth para repetir espaços. Isso mostra que você sabe apresentar resultados hierárquicos, não apenas calculá-los.

WITH RECURSIVE org AS (
    SELECT id, name, 1 AS depth
    FROM employees WHERE manager_id IS NULL
    UNION ALL
    SELECT e.id, e.name, o.depth + 1
    FROM employees e JOIN org o ON e.manager_id = o.id
)
SELECT REPEAT('  ', depth - 1) || name AS tree
FROM org
ORDER BY depth;

Acumulando o caminho

Para mostrar o caminho completo do CEO até cada pessoa, mantenha uma string path. Essa é a mesma técnica da lição anterior, aplicada ao organograma.

WITH RECURSIVE org AS (
    SELECT id, name, CAST(name AS VARCHAR(500)) AS path
    FROM employees WHERE manager_id IS NULL
    UNION ALL
    SELECT e.id, e.name, o.path || ' / ' || e.name
    FROM employees e JOIN org o ON e.manager_id = o.id
)
SELECT name, path FROM org ORDER BY path;

Contando subordinados por gerente

Uma pergunta frequente de acompanhamento: "Quantas pessoas, direta ou indiretamente, se reportam a cada gerente?" Use a subárvore recursiva de cada gerente e depois agregue os resultados. Um padrão comum é executar a recursão uma vez por raiz e usar GROUP BY no gerente inicial.

Aqui, contamos todos os subordinados indiretos abaixo de Ada (a CEO), percorrendo toda a árvore e contando as linhas abaixo da raiz.

WITH RECURSIVE org AS (
    SELECT id, name, manager_id, 0 AS depth
    FROM employees WHERE id = 1
    UNION ALL
    SELECT e.id, e.name, e.manager_id, o.depth + 1
    FROM employees e JOIN org o ON e.manager_id = o.id
)
SELECT COUNT(*) - 1 AS total_reports FROM org;

Erros comuns

Fique atento a estas armadilhas que os entrevistadores costumam preparar:

  • Direção errada da junção — usar e.manager_id = cte.id quando você pretendia subir retorna o conjunto errado.
  • Esquecer o filtro da âncora — omitir WHERE id = X inicializa todas as linhas e retorna toda a floresta.
  • Profundidade deslocada em um — decida se a semente é a profundidade 0 ou 1 e mantenha essa decisão de forma consistente.

Por que não usar apenas uma autojunção?

Uma autojunção pode buscar uma quantidade fixa de níveis: uma junção para subordinados diretos, duas para subordinados de segundo nível e assim por diante. Mas você precisa conhecer a profundidade antecipadamente e escrever uma junção para cada nível.

Uma CTE recursiva lida com uma profundidade arbitrária e desconhecida em uma única consulta. Quando um entrevistador diz "a hierarquia pode ter qualquer número de níveis", isso elimina as autojunções simples e indica o uso de recursão.

Verificação rápida

Certifique-se de que você consegue inverter a direção do percurso.

Recapitulação

O percurso do organograma é a estrutura recursiva aplicada a uma tabela autorreferente:

  • Para baixo: inicie com um gerente e faça a junção usando e.manager_id = cte.id.
  • Para cima: inicie com um funcionário e faça a junção usando e.id = cte.manager_id.
  • Mantenha depth para a indentação e path para a cadeia completa.
  • A recursão lida com qualquer profundidade desconhecida, algo que uma autojunção não consegue fazer.

Próximo: usar a recursão para gerar séries de números e datas.

Perguntas Frequentes

A aula “Percorrendo um organograma” é grátis?

Sim — o texto completo de “Percorrendo um organograma” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de SQL Interview Prep, atualize para CoddyKit PRO. O curso de SQL Interview Prep inclui 4 aulas no total.

O que vou aprender em “Percorrendo um organograma”?

Percorra uma hierarquia funcionário-gerente até qualquer profundidade. Você pratica SQL Interview Prep com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar SQL Interview Prep?

Nenhuma experiência prévia é necessária. SQL Interview Prep no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Percorrendo um organograma”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de SQL Interview Prep?

Sim. Cada aula de SQL Interview Prep inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Membros âncora e recursivos
  2. Percorrendo um organograma
  3. Gerando séries de números e datas
  4. Evitando recursão infinita
← Voltar para SQL Interview Prep