Todos os artigos
176 artigos · atualizado semanalmente Veja nossas Ferramentas
Todos os artigos
Comparativos

Quando usar MongoDB (e quando PostgreSQL é melhor)

Use MongoDB quando a entidade é lida e gravada como um bloco e o schema varia. Prefira PostgreSQL para relações N:N, relatórios e transações.

Quando usar MongoDB (e quando PostgreSQL é melhor)
COVER · Comparativos

Você abriu o MongoDB porque alguém no time disse que "schema rígido atrasa o produto", modelou tudo como documento aninhado e, três meses depois, está escrevendo $lookup em cima de $lookup para juntar pedidos, clientes e pagamentos. A sensação é familiar: você reinventou o JOIN, só que com menos ajuda do banco, e as transações entre coleções, que existem, ficaram mais caras e mais limitadas do que você imaginava. O problema raramente é o MongoDB. É ter escolhido o modelo de documentos para um dado que, no fundo, é relacional.

A resposta curta: use MongoDB quando a entidade tem uma fronteira clara (é lida e gravada como um bloco, por uma chave) e o formato varia entre registros. Prefira PostgreSQL quando o dado é uma rede de relações consultada de vários ângulos, quando há relatórios cruzados e quando a regra de negócio depende de transações entre várias entidades. O resto deste post detalha esses critérios, com exemplos que eu rodei no MongoDB 8.0 e no PostgreSQL 17.

O que é, de fato, um documento

No modelo relacional você quebra uma entidade em várias tabelas normalizadas e remonta com JOINs na hora da leitura. No MongoDB você guarda a entidade do jeito que ela é consumida: um pedido com seus itens e um snapshot do cliente, tudo num único documento BSON.

{
  "_id": "ord_8821",
  "cliente": { "id": "cli_42", "nome": "Ana Lima" },
  "itens": [
    { "sku": "TEC-01", "qtd": 2, "preco": 149.9 },
    { "sku": "MOU-03", "qtd": 1, "preco": 89.0 }
  ],
  "total": 388.8,
  "status": "pago"
}

A regra que a própria documentação do MongoDB repete é: dados acessados juntos ficam guardados juntos. Se a sua tela mostra o pedido inteiro de uma vez, ler esse documento é uma única consulta por _id, sem JOIN. É aí que o modelo de documentos brilha, e é aí que a maioria das pessoas erra ao avaliar a tecnologia: julga o banco pelo caso em que o dado não tem esse formato.

MongoDB vs PostgreSQL em 5 critérios

Critério MongoDB PostgreSQL
Forma do dado Agregado autocontido, lido por chave Entidades independentes ligadas por relações
JOINs $lookup no pipeline de agregação; funciona, mas o modelo pede para evitar JOIN é o caso de uso central, com otimizador maduro
Transações Multi-documento desde 4.0 (replica set) e 4.2 (sharded); limite padrão de 60 s ACID entre quaisquer tabelas, sem limite de duração por padrão
Schema Flexível por padrão; validação opcional com $jsonSchema Rígido por padrão; flexível onde você quiser com JSONB
Escala horizontal Sharding nativo por chave Réplicas de leitura nativas; sharding de escrita depende de extensão ou arquitetura

A última linha da tabela é a que mais pesa na conversa e a que menos importa para a maioria dos projetos: um único servidor PostgreSQL bem configurado aguenta muito mais do que a maioria dos produtos vai precisar. Se a decisão for entre PostgreSQL e outro relacional, o comparativo de PostgreSQL vs MySQL cobre a outra metade da escolha.

Quando usar MongoDB

Documentos vencem quando o formato do dado e o padrão de acesso estão a favor:

  • A entidade é lida e escrita como um bloco. Carrinho, perfil de usuário, configuração de conta, post com comentários embutidos. Você quase nunca quer "só os itens" sem o pedido.
  • O schema varia entre registros. Catálogo de produtos em que uma TV tem polegadas e uma camiseta tem tamanho. No relacional isso vira coluna nula ou tabela de atributos genérica (o famigerado EAV); no documento, cada produto carrega só os campos que tem.
  • O dado evolui rápido e vários formatos convivem. O ganho aqui não é fugir do custo do ALTER TABLE (já falo disso), e sim poder ter documentos antigos e novos lado a lado sem uma migração coordenada a cada mudança.
  • Você precisa escalar escrita horizontalmente. O sharding nativo distribui documentos por chave entre shards. É um caminho mais direto do que particionar um relacional na mão.
  • O dado já chega semiestruturado. Eventos, payloads de webhook, telemetria: coisas de alto volume que entram em formatos irregulares.

Repare no padrão: todos esses casos têm uma fronteira de agregação clara. O documento é a unidade natural de leitura e de escrita.

"Schema flexível" não quer dizer "sem schema"

Desde a versão 3.6, o MongoDB valida documentos com $jsonSchema no momento da escrita. Flexível é o padrão, não a única opção:

db.createCollection("pedidos", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["cliente", "itens", "total", "status"],
      properties: {
        itens: { bsonType: "array", minItems: 1 },
        total: { bsonType: ["double", "int", "decimal"], minimum: 0 },
        status: { enum: ["aberto", "pago", "cancelado"] }
      }
    }
  }
})

db.pedidos.insertOne({ cliente: { id: "cli_42" }, itens: [], total: 0, status: "pago" })
// MongoServerError: Document failed validation

Rodei no MongoDB 8.0: o pedido sem itens é recusado. Se o argumento para escolher MongoDB é "não queremos schema", vale saber que em algum momento você vai querer, e que dá para ter.

Quando não usar MongoDB (e PostgreSQL é melhor)

Aqui mora o erro de origem. O modelo de documentos cobra caro quando o dado é, na essência, uma rede de relações muitos-para-muitos consultada de ângulos diferentes:

  • Muitos JOINs entre entidades independentes. Se quase toda query precisa de $lookup ligando coleções distintas, o dado é relacional. O $lookup funciona, mas você está usando o banco no terreno onde ele é menos natural.
  • Transações entre várias entidades são o centro da regra. O MongoDB tem transações ACID multi-documento desde a 4.0 em replica sets e desde a 4.2 em clusters shardados. Elas funcionam: rodei a transferência entre duas contas abaixo num replica set de um nó e o commit foi atômico. Mas a documentação é explícita que uma transação distribuída custa mais que escritas em um único documento e que ela não substitui um bom desenho de schema. E há limites: por padrão a transação precisa terminar em menos de um minuto (transactionLifetimeLimitSeconds = 60), e em mongod standalone ela nem está disponível.
  • A mesma informação é consultada por vários eixos. Um relatório que cruza vendas por região, por vendedor e por produto se beneficia de tabelas normalizadas e SQL. Duplicar isso em documentos vira pesadelo de consistência.
  • Auditoria e relatórios assumem SQL. Ferramentas de BI, conciliação e auditoria costumam falar SQL de primeira. Não é exigência regulatória escolher um tipo de banco, mas é atrito real quando o dado financeiro mora num banco de documentos.
const s = db.getMongo().startSession()
const contas = s.getDatabase("loja").contas
s.startTransaction()
try {
  contas.updateOne({ _id: "A", saldo: { $gte: 300 } }, { $inc: { saldo: -300 } })
  contas.updateOne({ _id: "B" }, { $inc: { saldo: 300 } })
  s.commitTransaction()
} catch (e) {
  s.abortTransaction()
  throw e
}

Existe ainda o custo silencioso: para evitar JOINs você duplica dados (o snapshot do cliente em cada pedido, por exemplo). Isso consome mais disco e cria o problema de manter cópias sincronizadas quando o original muda. Se você se pegou escrevendo rotinas para propagar a troca de nome de um cliente por 40 mil documentos, o modelo está errado para esse dado. Às vezes o snapshot é o comportamento certo (o pedido deve guardar o endereço da época da compra), e aí a duplicação é feature; a pergunta é se a cópia deveria mudar quando o original muda.

O argumento do ALTER TABLE envelheceu

Um argumento clássico a favor de documentos é que "adicionar um campo não exige ALTER TABLE em milhões de linhas". No PostgreSQL, isso deixou de ser verdade na versão 11: ADD COLUMN com default não volátil passou a ser só uma alteração de metadado, sem reescrever a tabela. Testei no PostgreSQL 17 com 1 milhão de linhas:

ALTER TABLE produtos ADD COLUMN ativo boolean NOT NULL DEFAULT true;
-- Time: 0.938 ms  (o arquivo da tabela, pg_relation_filenode, não mudou)

O ganho real do MongoDB nessa frente não é o custo do ALTER. É poder conviver com formatos diferentes sem migração coordenada, o que é ótimo no começo de um produto e vira dívida quando ninguém sabe mais quais formatos existem na coleção.

Embutir ou referenciar: a decisão que define tudo

Dentro do próprio MongoDB existe a escolha que mais separa projetos saudáveis de projetos sofridos: embedding (aninhar) versus referencing (referenciar por id, no estilo chave estrangeira).

Embuta quando a relação é de contenção e o filho não vive sozinho: itens de um pedido, comentários de um post com pouco volume. Referencie quando o sub-objeto é grande, cresce sem limite ou é compartilhado por vários pais. A escolha do identificador também conta; os trade-offs de chave natural contra chave artificial do post sobre chave primária natural ou surrogate valem igual para o _id.

// Embedding: itens vivem dentro do pedido
db.pedidos.findOne({ _id: "ord_8821" })  // tudo em 1 leitura

// Referencing: comentários numa coleção própria
db.comentarios.find({ post_id: "post_42" }).limit(20)

// E quando precisa juntar, $lookup:
db.pedidos.aggregate([
  { $lookup: { from: "clientes", localField: "cliente.id", foreignField: "_id", as: "cli" } }
])

Documentos no MongoDB têm limite de 16 MB (o limite de tamanho de documento BSON). Uma lista que cresce para sempre, como o feed de atividades de um usuário ativo há anos, não pode ser embutida: vai estourar o documento. Na prática, esse limite é o seu detector de modelagem errada.

A escolha não é binária

Times maduros não escolhem "MongoDB ou PostgreSQL" para o sistema inteiro. Escolhem por contexto: catálogo de produtos em documentos, livro-razão financeiro no relacional, sessões e cache no Redis (o post sobre casos de uso do Redis cobre esse pedaço). Para a diferença mais ampla entre as famílias de banco, o comparativo banco relacional vs NoSQL trata a decisão num nível mais arquitetural. E se o projeto é pequeno o bastante para nem ter servidor de banco, o post sobre quando usar SQLite é a leitura certa.

O PostgreSQL, aliás, tem JSONB, que guarda documentos com índice GIN e operadores de contenção:

CREATE INDEX produtos_attrs_gin ON produtos USING gin (attrs jsonb_path_ops);

SELECT nome, preco FROM produtos WHERE attrs @> '{"tamanho": "M"}';

Para uma fatia pequena de dado flexível (os atributos variáveis do catálogo) dentro de um sistema majoritariamente relacional, isso resolve sem trazer um segundo banco para operar, fazer backup e monitorar.

Perguntas frequentes

Quando usar MongoDB em vez de um banco relacional?

Quando a entidade é lida e gravada como um bloco coeso, o schema varia entre registros, vários formatos precisam conviver ou você precisa de escala horizontal de escrita. Se o seu padrão de acesso é "pega o documento inteiro por uma chave", o modelo de documentos é direto e rápido.

Quando não usar MongoDB?

Quando o dado é uma rede de relações muitos-para-muitos consultada por vários ângulos, quando a regra de negócio depende de transações entre muitas entidades, ou quando relatórios e auditoria cruzam tudo com tudo. Se você está escrevendo $lookup em quase toda query, o dado é relacional.

MongoDB tem transações ACID?

Tem. Transações multi-documento existem desde a versão 4.0 em replica sets e desde a 4.2 em clusters shardados. A própria documentação avisa que elas custam mais que escritas em um documento só e não substituem um bom desenho de schema; por padrão, uma transação expira se passar de 60 segundos.

Dá para usar MongoDB e PostgreSQL no mesmo projeto?

Sim, e é comum. Use cada banco onde ele é forte: documentos para entidades autocontidas e de schema variável, relacional para o núcleo transacional e relatórios cruzados. Se a parte flexível é pequena, JSONB no próprio PostgreSQL costuma ser suficiente e poupa um banco a mais na operação.

Escolha pela forma do dado, não pela moda

O modelo de documentos não é "o futuro" nem "moda passageira": é uma escolha sobre a forma do seu dado. Pergunte se a entidade tem uma fronteira de agregação clara, se é lida como um bloco e se o limite de 16 MB dá folga. Se sim, MongoDB vai te servir bem, com validação de schema onde você precisar. Se você se vê reconstruindo JOINs com $lookup, sincronizando cópias na mão ou brigando com transações entre coleções, aquele dado queria ser uma tabela desde o começo. Quando vou inspecionar um documento real antes de decidir (um export do mongoexport ou a resposta de uma API), colo no JSON Formatter para enxergar a árvore inteira e ver o que de fato é lido junto.

RD
Autor
Rafael Duarte
Desenvolvedor backend com passagem por fintech e SaaS B2B — trabalhou em times que escalaram APIs de zero a milhões de requisições. Carrega cicatrizes de produção suficientes para ter opiniões fortes sobre ferramentas, padrões e decisões de arquitetura. Não é acadêmico: leu a RFC do UUID quando precisou escolher entre v4 e v7 para uma tabela de alta escrita.
Ver perfil