Padrões de valores atípicos e de estruturas em árvore
Os alunos tratarão documentos com matrizes excepcionalmente grandes usando o padrão de valores atípicos e modelarão dados hierárquicos em árvore com referências aos pais ou caminhos materializados.
Padrões de valores atípicos e de estruturas em árvore é uma aula grátis de MongoDB Academy no CoddyKit. Esta é a aula 4 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 MongoDB Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de MongoDB Academy inclui 4 aulas no total.
O Problema dos Valores Discrepantes
A maioria das coleções do MongoDB contém documentos que seguem uma distribuição de tamanho previsível. Porém, ocasionalmente surgem valores discrepantes — documentos que se desviam drasticamente do padrão. Uma publicação em uma rede social que se torna viral pode acumular 50.000 comentários, enquanto as publicações comuns têm de 5 a 20. Um produto curtido por uma celebridade pode ter 10.000 avaliações. Projetar seu esquema com base no caso médio e ignorar os valores discrepantes faz com que os documentos eventualmente atinjam o limite de 16 MB ou causem pressão de memória.
Detectando Documentos Discrepantes
Antes de projetar uma solução para valores discrepantes, identifique se eles realmente existem nos seus dados. Use um pipeline de agregação para encontrar documentos com matrizes excepcionalmente grandes. Defina um limite com base no seu intervalo normal esperado — se 99% das publicações tiverem menos de 100 comentários, documentos com mais de 1.000 comentários são valores discrepantes que merecem tratamento especial.
// Find posts with outlier-level comment counts
db.posts.aggregate([
{
$project: {
title: 1,
commentCount: { $size: { $ifNull: ['$comments', []] } }
}
},
{ $match: { commentCount: { $gt: 1000 } } },
{ $sort: { commentCount: -1 } },
{ $limit: 10 }
])O Padrão de Valores Discrepantes: Sinalizador de Excedente
O Padrão de Valores Discrepantes mantém o caso normal rápido incorporando matrizes até um determinado limite e trata documentos excepcionais definindo um sinalizador hasOverflow e armazenando os itens excedentes em uma coleção separada. O código da aplicação verifica o sinalizador — se for falso (o caso comum), usa a matriz incorporada. Se for verdadeiro (o caso discrepante), executa uma consulta adicional à coleção de excedentes.
// Normal post document (99% of posts)
{ _id: ObjectId(), title: 'Regular Post', comments: [/* up to 100 */], hasOverflow: false }
// Outlier post document
{
_id: ObjectId(),
title: 'Viral Post',
comments: [/* first 100 comments */],
hasOverflow: true // more comments in overflow collection
}
// Overflow collection document
{ postId: ObjectId('...'), comments: [/* comments 101-5000 */] }Leitura com o Padrão de Valores Discrepantes
O código da aplicação deve tratar explicitamente o sinalizador de valores discrepantes. Na maior parte do tempo, o sinalizador é falso e as leituras são rápidas. Para documentos discrepantes, execute a consulta adicional aos excedentes. Isso mantém otimizado o caminho comum e trata corretamente os casos excepcionais, sem aumentar excessivamente os documentos normais nem atingir o limite de 16 MB.
async function getPostWithComments(postId) {
const post = await db.collection('posts').findOne({ _id: postId })
if (!post.hasOverflow) {
return post // fast path — all comments embedded
}
// Outlier path — fetch additional comments from overflow
const overflow = await db.collection('postOverflow').findOne({ postId })
return {
...post,
comments: [...post.comments, ...(overflow?.comments ?? [])]
}
}Introdução aos Padrões de Estruturas de Árvore
Dados hierárquicos — categorias de produtos, organogramas, sistemas de arquivos e tópicos de comentários — aparecem em praticamente todas as aplicações. O MongoDB não tem um tipo de dados nativo para árvores, portanto a estrutura precisa ser modelada no esquema do documento. Há quatro padrões comuns de árvore, cada um otimizado para diferentes formas de acesso às consultas: Referências ao Pai, Referências aos Filhos, Matriz de Ancestrais e Caminhos Materializados.
Referências ao Pai: Hierarquia Simples
O padrão de Referência ao Pai armazena cada nó com um único campo parent que aponta para o _id de seu pai. Os nós raiz têm parent: null. Essa é a representação mais simples e se assemelha ao funcionamento das árvores de conjuntos aninhados ou de listas de adjacência do SQL. Ela é eficiente para encontrar o pai direto de um nó ou seus filhos diretos, mas exige consultas recursivas para percorrer vários níveis.
// Category tree with Parent References
db.categories.insertMany([
{ _id: 1, name: 'Electronics', parent: null },
{ _id: 2, name: 'Phones', parent: 1 },
{ _id: 3, name: 'Laptops', parent: 1 },
{ _id: 4, name: 'Smartphones', parent: 2 },
{ _id: 5, name: 'Feature Phones',parent: 2 }
])
// Find direct children of 'Electronics'
db.categories.find({ parent: 1 })Matriz de Ancestrais: Consulta Rápida de Ancestrais
O padrão de Matriz de Ancestrais armazena o caminho completo da raiz até o nó atual em uma matriz ancestors. Isso torna trivial responder “X é um ancestral de Y?” com uma simples verificação de associação na matriz. Também facilita encontrar todos os descendentes de um nó — consulte os documentos cuja matriz ancestors contenha o _id desse nó. A desvantagem é que mover uma subárvore exige atualizar todos os documentos descendentes.
// Array of Ancestors pattern
db.categories.insertMany([
{ _id: 1, name: 'Electronics', ancestors: [] },
{ _id: 2, name: 'Phones', ancestors: [1] },
{ _id: 4, name: 'Smartphones', ancestors: [1, 2] } // root→Electronics→Phones
])
// Find all descendants of Electronics (id=1)
db.categories.find({ ancestors: 1 })
// Check if Electronics is an ancestor of Smartphones
db.categories.findOne({ _id: 4, ancestors: 1 }) // not null = yesCaminhos Materializados: Árvore Baseada em Texto
O padrão de Caminho Materializado armazena o caminho completo como uma cadeia de caracteres (por exemplo, '/Electronics/Phones/Smartphones'). Ele permite consultas por prefixo para encontrar todos os nós sob uma subárvore e consultas com expressões regulares para pesquisar dentro dos segmentos do caminho. Esse padrão se adapta naturalmente a caminhos de sistemas de arquivos ou hierarquias de URLs. É eficiente tanto para consultar ancestrais quanto para enumerar descendentes, mas pode ser frágil quando os nós são renomeados ou movidos.
// Materialised Path pattern
db.categories.insertMany([
{ _id: 1, name: 'Electronics', path: ',1,' },
{ _id: 2, name: 'Phones', path: ',1,2,' },
{ _id: 4, name: 'Smartphones', path: ',1,2,4,' }
])
// Find all descendants of Phones (id=2) — path contains ',2,'
db.categories.find({ path: /,2,/ })
// Find the full path ancestors of Smartphones
db.categories.find({ _id: { $in: [1, 2] } }) // parse path and lookup idsEscolhendo o Padrão de Árvore Adequado
Escolha o padrão de árvore com base na sua consulta mais frequente: Referências ao Pai — simples e adequado para percursos com recursão no lado da aplicação; Referências aos Filhos — incorpora uma matriz de filhos diretos, com leitura rápida de um nível; Matriz de Ancestrais — rápida para consultar ancestrais e subárvores, mas cara para movimentações; Caminhos Materializados — rápidos para consultas de subárvores baseadas em expressões regulares, mas frágeis ao renomear. Abordagens híbridas (armazenando tanto o pai quanto os ancestrais) trocam complexidade de escrita por velocidade de leitura.
Referências aos Filhos: Incorporando Filhos Diretos
O padrão de Referências aos Filhos incorpora uma matriz de valores _id dos filhos diretos em cada documento de nó. Isso torna rápida a recuperação de todos os filhos de um nó em uma única leitura (sem necessidade de uma consulta separada). É ideal para árvores lidas frequentemente de cima para baixo (por exemplo, quando um menu renderiza imediatamente seus filhos). A desvantagem é que a matriz de filhos pode crescer muito em nós largos, e não é possível encontrar com eficiência o pai de um nó sem um índice ou campo adicional.
// Child References pattern
db.categories.insertMany([
{ _id: 1, name: 'Electronics', children: [2, 3] },
{ _id: 2, name: 'Phones', children: [4, 5] },
{ _id: 3, name: 'Laptops', children: [] },
{ _id: 4, name: 'Smartphones', children: [] },
{ _id: 5, name: 'Feature Phones', children: [] }
])
// Get direct children of Electronics in one read
const parent = db.categories.findOne({ _id: 1 })
const children = db.categories.find({ _id: { $in: parent.children } }).toArray()Usando $graphLookup para Percorrer Árvores
O estágio de agregação $graphLookup do MongoDB segue recursivamente campos de referência para percorrer uma árvore ou um grafo armazenado em qualquer padrão. Ele retorna todos os nós alcançáveis até uma profundidade especificada. Use-o com Referências ao Pai ou Referências aos Filhos para percorrer hierarquias sem escrever código recursivo na aplicação. Especifique maxDepth para evitar loops infinitos em grafos circulares.
// Traverse all descendants of Electronics using $graphLookup
db.categories.aggregate([
{ $match: { _id: 1 } }, // start from Electronics
{
$graphLookup: {
from: 'categories',
startWith: '$_id',
connectFromField: '_id',
connectToField: 'parent',
as: 'descendants',
maxDepth: 10
}
}
])Verificação Rápida
Avalie sua compreensão dos conceitos de MongoDB e bancos de dados NoSQL desta lição.
Recapitulação da Lição
Nesta lição, você aprendeu que: o Padrão de Valores Discrepantes mantém os documentos normais enxutos ao incorporar matrizes até um determinado limite e usar um sinalizador hasOverflow para direcionar documentos excepcionais a uma coleção de excedentes; os padrões de estruturas de árvore (Referências ao Pai, Matriz de Ancestrais e Caminhos Materializados) otimizam diferentes formas de acesso às consultas em dados hierárquicos; e $graphLookup percorre recursivamente referências no pipeline sem recursão no lado da aplicação. Em seguida, compararemos o MongoDB com o Redis para cargas de trabalho de documentos e de chave-valor.
Aprenda JavaScript com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 30
- Aulas
- 120
Perguntas Frequentes
A aula “Padrões de valores atípicos e de estruturas em árvore” é grátis?
Sim — o texto completo de “Padrões de valores atípicos e de estruturas em árvore” é 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 MongoDB Academy, atualize para CoddyKit PRO. O curso de MongoDB Academy inclui 4 aulas no total.
O que vou aprender em “Padrões de valores atípicos e de estruturas em árvore”?
Os alunos tratarão documentos com matrizes excepcionalmente grandes usando o padrão de valores atípicos e modelarão dados hierárquicos em árvore com referências aos pais ou caminhos materializados. Você pratica MongoDB Academy 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 MongoDB Academy?
Nenhuma experiência prévia é necessária. MongoDB Academy 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 4 de 4.
Quanto tempo leva a aula “Padrões de valores atípicos e de estruturas em árvore”?
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 MongoDB Academy?
Sim. Cada aula de MongoDB Academy 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
- Padrões de agrupamento e de valores calculados
- Padrões de referência estendida e de subconjunto
- Padrões polimórficos e de versionamento de esquema
- Padrões de valores atípicos e de estruturas em árvore