CS Fundamentals Trainer · Guias
Escolhendo um banco de dados: padrões de acesso, trade-offs e custos medidos
Como escolher um banco de dados a partir das perguntas que você fará a ele: as principais famílias (relacional, documentos, chave-valor, colunas largas, grafos, busca, colunar, séries temporais) e seus trade-offs, comparações medidas de documentos contra tabelas, consultas com e sem índice, saltos em grafos, busca de texto completo e layout por linhas contra colunas, um sistema de registro com armazenamentos derivados e uma lista de verificação para discussões de design.
34 min de leitura
"Devemos usar Postgres, MongoDB, Cassandra, DynamoDB ou Redis?" é uma das perguntas mais comuns em discussões de design, e a forma habitual de respondê-la, comparando funcionalidades de produtos, é a forma errada. Produtos vêm e vão; a pergunta útil é qual é o formato dos dados e que perguntas você fará a eles. Os pedidos de uma loja, o histórico de um chat, um bilhão de leituras de sensores, um grafo social e uma caixa de busca guardam "dados", e cada um deles é barato em um tipo de banco de dados e dolorosamente lento em outro.
Este guia dá uma forma de escolher. Ele parte dos padrões de acesso, percorre as principais famílias de bancos de dados e o que cada uma faz bem, e então testa o folclore com medições: documentos contra tabelas, consultas ad hoc sem índice, travessias de grafos, busca de texto completo e layout por linhas contra layout por colunas. Termina com o padrão em que a maioria dos sistemas reais acaba (um sistema de registro, mais armazenamentos derivados alimentados por ele) e com uma lista de verificação que você pode usar em uma entrevista ou em uma revisão de design.
Uma nota sobre as medições. Os números marcados como "medido" vêm de experimentos escritos para este guia: PostgreSQL 16 em uma pequena VM na nuvem (2 vCPUs de um Intel Xeon a 2,1 GHz, 8 GB de memória), uma única conexão de cliente, caches aquecidos, mais programas em Go 1.24 para as comparações em memória. O código está no apêndice. Os números absolutos serão diferentes no seu hardware e com os seus dados, então leia-os pelas proporções e pelo formato da curva, não pelos milissegundos. Eles também não dizem que o PostgreSQL é melhor do que qualquer outro produto; mostram o que acontece quando um tipo de consulta encontra um tipo de armazenamento.
1. Comece pelos padrões de acesso, não pelo produto
Antes de nomear um banco de dados, anote as perguntas que a aplicação faz, com uma estimativa de frequência (veja o guia de estimativa de capacidade para obter esses números). Para uma loja, a lista pode ser assim:
| Pergunta | Formato | Frequência |
|---|---|---|
| Mostrar o pedido 8213 com suas linhas | buscar um registro pela chave, com seus filhos | muito alta |
| Mostrar todos os pedidos do cliente 77 | listar por um atributo secundário | alta |
| Reservar o estoque e criar o pedido, ou nenhum dos dois | gravar vários registros de forma atômica | alta |
| Receita por produto no último trimestre | varrer e agregar tudo | baixa, mas pesada |
| Buscar produtos por palavras do nome | correspondência de texto e ranqueamento | alta |
| Quem comprou isto também comprou… | travessia de relacionamentos | média |
Cada linha aponta para um ponto forte diferente. Buscar pela chave é o que todo banco de dados faz bem. Gravações atômicas de vários registros exigem transações. Varrer tudo é aquilo para o qual os armazenamentos colunares foram feitos. Texto e relacionamentos têm suas próprias estruturas especializadas. Um banco de dados é uma aposta sobre quais dessas perguntas importarão, então a disciplina é listar as perguntas primeiro e deixar que elas classifiquem os candidatos.
Mais três fatos decidem muito e são fáceis de esquecer:
- Quantos dados, e com que velocidade eles crescem? Gigabytes cabem em uma máquina e fazem quase qualquer escolha funcionar. Terabytes de dados quentes, ou taxas de escrita além do disco de uma máquina, forçam o particionamento, e o particionamento muda quais consultas continuam baratas.
- Quem precisa que os dados estejam corretos, e quão corretos? Dinheiro e estoque precisam de atualizações atômicas e restrições. Um contador de visualizações pode perder alguns incrementos.
- Como as perguntas vão mudar? Um produto em seu primeiro ano inventa novas perguntas toda semana. Alguns bancos de dados tornam uma nova pergunta barata (adicionar um índice, escrever uma consulta) e outros a transformam em um redesenho.
2. As famílias, em uma tabela
| Família | Os dados parecem | Forte em | Fraca em | Exemplos típicos |
|---|---|---|---|---|
| Relacional (SQL) | tabelas com colunas tipadas, relacionadas por chaves | transações, restrições, junções, consultas ad hoc | os limites de uma máquina (sem trabalho extra), travessia profunda de grafos | PostgreSQL, MySQL |
| Documentos | registros autocontidos, parecidos com JSON | buscar um agregado inteiro em uma leitura, campos flexíveis | junções e transações entre documentos, análise ad hoc | MongoDB, Couchbase |
| Chave-valor | um valor opaco atrás de uma chave | as buscas mais simples e rápidas; fácil de particionar | qualquer pergunta que não seja "dê-me o valor desta chave" | Redis, DynamoDB (uso básico) |
| Colunas largas | linhas agrupadas por uma chave de partição e ordenadas dentro dela | volume enorme de escrita, leituras por intervalo dentro de uma partição, escala horizontal | consultas que não combinam com o desenho de chaves da tabela, junções | Cassandra, Bigtable, DynamoDB |
| Grafos | nós e arestas com propriedades | consultas de relacionamento com muitos saltos | agregação em massa, particionar um grafo muito conectado | Neo4j e similares |
| Busca | um índice invertido sobre texto | palavras, ranqueamento, tolerância a erros de digitação, facetas | ser a fonte da verdade, transações | Elasticsearch, OpenSearch, Solr |
| Séries temporais | medições com carimbos de tempo | taxas enormes de inserção, consultas por janela de tempo, retenção, redução de resolução | atualizar pontos antigos, consultas de uso geral | TimescaleDB, InfluxDB, Prometheus |
| Colunar / analítico | a mesma tabela, armazenada por coluna | varrer e agregar poucas colunas de bilhões de linhas | leituras e atualizações de uma linha | ClickHouse, BigQuery, Redshift |
| Armazenamento de objetos | arquivos (blobs) por nome | armazenamento barato e durável de coisas grandes | consultas dentro dos arquivos, leituras pequenas de baixa latência | S3 e similares |
Duas observações sobre a tabela. Primeiro, as famílias se sobrepõem: o PostgreSQL guarda documentos JSON, faz busca de texto completo e executa consultas recursivas de grafos; o Redis pode persistir dados; o DynamoDB é ao mesmo tempo chave-valor e colunas largas. A tabela diz para o que cada projeto é otimizado, não ao que ele está limitado. Segundo, as colunas da direita importam tanto quanto as da esquerda: todo ponto forte é pago com uma fraqueza, e a fraqueza é o que você descobre em produção.
3. Relacional primeiro, e por que isso é um padrão e não uma religião
Um banco de dados relacional dá, de uma só vez, quatro coisas que são caras de reconstruir depois:
- Transações (ACID): várias mudanças acontecem juntas ou não acontecem, e usuários concorrentes não veem trabalho pela metade.
- Restrições: o próprio banco de dados rejeita um pedido sem cliente, um saldo negativo ou um e-mail duplicado. Bugs no código da aplicação não conseguem corromper dados que o esquema proíbe.
- Junções e uma linguagem de consulta: qualquer pergunta sobre os dados pode ser feita sem ter sido planejada, e o planejador escolhe como respondê-la.
- Índices que podem ser adicionados depois: um novo padrão de acesso costuma ser um único
CREATE INDEX.
Os dois últimos importam mais enquanto você ainda está aprendendo o que o produto é. Um armazenamento de documentos ou chave-valor costuma ser desenhado em torno das consultas conhecidas no primeiro dia; um esquema relacional é desenhado em torno dos fatos e pode responder a perguntas que ninguém tinha ainda.
Medido: os mesmos pedidos como tabelas e como documentos
O experimento guarda 1.000.000 de pedidos duas vezes no PostgreSQL: normalizados em orders e order_items (3.000.000 de linhas, de 1 a 5 por pedido), e como um documento JSONB por pedido, com as linhas embutidas (cerca de 258 bytes de texto cada).
| Pergunta | Tabelas | Documentos |
|---|---|---|
| Buscar um pedido com suas linhas (pelo id) | 0,137 ms (junção de duas tabelas) | 0,085 ms (uma linha) |
| Pedidos de um cliente, com índice no cliente | 0,106 ms | 0,127 ms (índice sobre uma expressão do JSON) |
| Pedidos de um cliente, sem índice | 160 ms | |
| Pedidos que contêm um produto, sem índice | 103 ms | 1.135 ms |
| Pedidos que contêm um produto, com índice | 0,123 ms (B-tree, 20 MB) | 4,0 ms (índice GIN, 74 MB) |
| Receita por produto, conjunto de dados inteiro | 0,52 a 0,56 s | 2,8 a 3,0 s |
| Tamanho em disco (dados e índices) | 418 MB | 435 MB |
Quatro conclusões decorrem daí, e elas são o coração do debate "documento ou relacional":
- Embutir vence ao ler um agregado. Uma leitura devolve o pedido e suas linhas, sem junção: aqui, 1,6 vez mais rápido. É para isso que os documentos servem, e importa mais quando as partes viveriam em máquinas diferentes.
- Sem um índice adequado, um armazenamento de documentos é uma varredura completa. 160 ms para uma busca que leva 0,1 ms com índice, sobre apenas um milhão de documentos pequenos. Isso não é uma falha dos documentos; é o que todo banco de dados faz quando nenhuma estrutura atende à pergunta. A falha está no hábito de escolher um armazenamento porque "não precisa de esquema" e depois fazer perguntas para as quais ele não foi moldado.
- Perguntas entre documentos custam mais. Contar por um valor dentro de listas aninhadas exigiu um índice maior e mais lento, e agregar sobre o conjunto inteiro foi cerca de cinco vezes mais lento do que sobre as tabelas, porque cada documento precisa ser aberto e interpretado.
- O tamanho não é o argumento. Os dois layouts ocuparam quase o mesmo espaço aqui. "Documentos são mais compactos" e "tabelas são mais compactas" são ambos folclore.
A regra prática: embuta o que é lido junto e muda junto (um pedido e suas linhas, uma postagem e seus comentários, se forem sempre exibidos juntos), referencie o que é compartilhado ou muda por conta própria (um produto, um cliente). Essa regra vale em documentos e em tabelas, e em ambos a questão é onde fica a fronteira do agregado.
4. Chave-valor e colunas largas: escalar estreitando as perguntas
Sistemas como DynamoDB, Cassandra e Bigtable nascem de uma troca: abrir mão da linguagem de consulta geral e das garantias entre registros e, em troca, obter buscas e escritas cujo custo não cresce com os dados. Eles conseguem isso particionando cada tabela por uma chave, de modo que qualquer requisição que nomeie a chave vá a um único lugar.
O que você ganha:
- Acesso previsível, em poucos milissegundos, pela chave em quase qualquer tamanho, com capacidade que cresce adicionando máquinas.
- Taxas de escrita muito altas. Os armazenamentos de colunas largas costumam anexar dados a um mecanismo de armazenamento estruturado em log, que transforma escritas aleatórias em sequenciais.
- Leituras por intervalo dentro de uma partição (todas as mensagens de uma conversa, em ordem de tempo), porque as linhas de uma partição são guardadas ordenadas.
O que custa:
- Todo padrão de acesso precisa ser desenhado com antecedência, em geral como sua própria tabela ou índice, com a chave pensada para aquela consulta. Uma nova pergunta é uma nova tabela e uma carga retroativa, não um
EXPLAINe um índice. - As transações são limitadas. Ou não existem, ou são restritas: o DynamoDB, por exemplo, oferece transações de no máximo 100 itens e 4 MB no total, nenhuma transação que atravesse regiões em uma tabela global, e nenhuma por meio de índices secundários. Verifique o que o armazenamento escolhido promete antes de construir sobre "vamos só usar uma transação".
- Chaves quentes. Se uma chave de partição recebe uma parcela desproporcional do tráfego (o feed de uma celebridade, um contador global), a partição vira o gargalo, e adicionar máquinas não ajuda.
- Análise ad hoc fraca. Qualquer coisa que varra muito é lenta ou cara, e por isso esses armazenamentos costumam ser combinados com um armazenamento analítico.
A medição anterior mostra o mesmo precipício em escala pequena: uma busca pela chave custa cerca de 0,1 ms, e a mesma pergunta sem estrutura utilizável custa 160 ms. Um armazenamento chave-valor faz do primeiro caminho o único caminho, de modo que o segundo não possa acontecer por acidente. Isso é uma vantagem quando você conhece as suas perguntas, e uma armadilha quando não conhece.
5. Grafos: o custo é o número de nós que você alcança
"Amigos de amigos" e "quem está ligado a quem em até quatro passos" são perguntas de relacionamento. Em um banco de dados relacional elas são autojunções, escritas com uma consulta recursiva. O experimento constrói um grafo de seguidores com 300.000 usuários e 3.000.000 de arestas (cerca de 10 seguidos cada um) e encontra todos a até h saltos de um usuário aleatório, no PostgreSQL com uma consulta recursiva e em um programa Go que mantém listas de adjacência em memória.
| Saltos | Usuários alcançados (média) | PostgreSQL, consulta recursiva | Go, listas de adjacência em memória |
|---|---|---|---|
| 2 | 110 | 0,33 ms | 0,004 ms |
| 3 | 1.108 | 1,7 ms | 0,027 ms |
| 4 | 10.886 | 13 ms | 0,18 ms |
| 5 | 91.298 | 120 ms | 2,0 ms |
| 6 | 285.698 | 919 ms | 14 ms |
Duas lições fáceis de perder:
- O banco de dados relacional serve bem para poucos saltos. Três saltos sobre três milhões de arestas levaram menos de dois milissegundos. Muitas decisões do tipo "precisamos de um banco de grafos" são tomadas para grafos que o PostgreSQL percorre com folga.
- O custo é definido por quantos nós a travessia alcança, em qualquer sistema. Cada salto extra alcança cerca de dez vezes mais usuários e custa cerca de oito vezes mais, nas duas colunas, até que a travessia cubra a maior parte do grafo: o salto seis alcança 95% de todos os usuários, e nenhum banco de dados torna isso barato. Bancos de grafos especializados ajudam com a constante (as listas de adjacência em memória foram de 60 a 80 vezes mais rápidas por consulta) e com uma linguagem de consulta de grafos, mas não mudam o fato de que grafos densos explodem.
Um armazenamento de grafos dedicado se justifica quando as consultas de relacionamento são o núcleo do produto (recomendações, anéis de fraude, grafos de controle de acesso de profundidade ilimitada), quando elas vão além de poucos saltos, ou quando são difíceis de expressar como junções. Para "mostrar as postagens dos meus amigos", você não precisa de um.
6. Busca: um índice invertido, não um LIKE
Procurar uma palavra dentro de um texto é um problema diferente de procurar um valor em uma coluna. A correspondência LIKE '%palavra%' não consegue usar um índice comum, então lê todas as linhas. Um índice de busca (um índice invertido) guarda, para cada palavra, a lista de documentos que a contêm, de modo que uma consulta lê apenas essas listas.
O experimento usa 500.000 documentos de 40 palavras cada (197 MB), no PostgreSQL:
| Consulta | Tempo |
|---|---|
LIKE '%palavra%', sem índice | 383 ms |
| Busca de texto completo com índice GIN, um termo | 1,7 ms |
| Busca de texto completo, dois termos com OR, ranqueada, os dez melhores | 3,5 ms |
O índice levou 13 segundos para ser construído e 90 MB de espaço, e a busca é mais de 200 vezes mais rápida. Note o que isso diz sobre a decisão: um banco de dados de uso geral com um índice de texto já resolve muita coisa. Um mecanismo de busca dedicado (Elasticsearch, OpenSearch, Solr) vale o seu custo operacional quando você precisa do que os recursos embutidos não dão: ajuste de relevância, tolerância a erros de digitação, análise de linguagem para muitos idiomas, facetas e filtros sobre grandes conjuntos de resultados, preenchimento automático, ou um corpus grande demais para um nó.
Lembre-se do que um mecanismo de busca não é: raramente é a fonte da verdade. Ele costuma ser alimentado pelo banco de dados principal (seção 9), pode ficar atrasado em relação a ele e pode perder ou reordenar atualizações de formas que você não aceitaria para pedidos. Trate-o como uma visão derivada e reconstruível.
7. Armazenamentos colunares: o layout combina com a pergunta
Um banco de dados orientado a linhas guarda todos os campos de um registro juntos, o que é ideal para "buscar este pedido" e para atualizar um registro. Uma consulta analítica, "some o preço de todos os pedidos acima de 900 nesta região", precisa de duas colunas em dez, e um layout por linhas arrasta as outras oito pela memória também. Um armazenamento orientado a colunas guarda cada coluna junta, de modo que a consulta lê apenas o que precisa, e valores parecidos lado a lado comprimem bem.
O experimento em Go mantém 10.000.000 de linhas de 10 inteiros (800 MB) em memória nos dois layouts, em uma única thread:
| Operação | Layout por linhas | Layout por colunas |
|---|---|---|
SUM(c3) WHERE c7 > 900 (2 colunas de 10) | 78 ms | 26 ms (3,0 vezes mais rápido) |
| Ler os 10 campos de 1.000.000 de linhas aleatórias | 47 ms (3,3 vezes mais rápido) | 156 ms |
Cada layout vence na fraqueza do outro, por um fator de cerca de três aqui. Sistemas analíticos reais fazem melhor do que esse modelo porque também comprimem as colunas e as processam em lotes, então a diferença em disco com bilhões de linhas é bem maior; mas o princípio é o mesmo. A consequência prática é arquitetural: não execute análises pesadas no seu banco transacional (isso deixa os usuários mais lentos), e não use um armazenamento colunar como banco principal da aplicação (leituras e atualizações de uma linha são o seu ponto fraco). Replique os dados para um armazenamento analítico.
8. O resto: séries temporais, objetos, caches, vetores
- Séries temporais. Métricas e dados de sensores têm muita inserção, são consultados por janela de tempo e são apagados ou reduzidos em resolução por idade. Armazenamentos dedicados (ou uma extensão de séries temporais de um banco relacional) particionam por tempo, o que torna a retenção um barato "descartar uma partição" e as consultas de janela recente rápidas.
- Armazenamento de objetos. Fotos, vídeos, backups e exportações pertencem a um armazenamento de objetos, com apenas a referência (chave, tamanho, tipo de conteúdo) no banco de dados. Colocar blobs grandes em linhas do banco deixa backups, replicação e caches mais pesados.
- Caches. Um armazenamento chave-valor em memória na frente do banco de dados absorve leituras repetidas. São dados derivados: sempre podem ser reconstruídos, então a questão é apenas o que acontece em uma falha de cache e quão desatualizada uma resposta pode estar.
- Busca vetorial. A busca por similaridade sobre embeddings é oferecida por armazenamentos dedicados e por extensões de bancos de uso geral. Como no texto, comece pelo que o banco existente consegue fazer e saia dele quando o volume ou a latência exigirem.
9. Um sistema de registro, e armazenamentos derivados ao redor
Sistemas reais raramente terminam com um único banco de dados. Terminam com um lugar onde cada fato é gravado e mantido correto (o sistema de registro, em geral relacional), e armazenamentos derivados que atendem a outros padrões de acesso: um índice de busca, um cache, um data warehouse analítico, um grafo de recomendações. Os armazenamentos derivados podem ser reconstruídos a partir do registro a qualquer momento, o que os torna seguros para experimentar.
Diagram: One system of record, several derived stores
A regra que mantém isso seguro é grave primeiro em um único lugar. Se a aplicação grava o pedido no banco de dados e também no índice de busca como dois passos independentes, um deles acabará falhando e os dois discordarão para sempre. Em vez disso, grave apenas no sistema de registro e anote a mudança em uma tabela de outbox na mesma transação; um retransmissor a publica para os armazenamentos derivados, que a aplicam de forma idempotente. Esse é exatamente o padrão, com sua análise de falhas, do guia sobre idempotência e efeitos exatamente uma vez.
O que isso custa: os armazenamentos derivados são eventualmente consistentes (um produto novo pode levar um segundo para aparecer na busca), você opera mais sistemas e precisa de um jeito de reconstruir cada um. O que isso compra é que cada padrão de acesso recebe a estrutura que o atende, sem fazer de nenhum deles o lugar onde a correção mora.
10. Quando uma máquina não basta
Um único servidor relacional bem configurado dá conta de mais do que a maioria dos produtos jamais precisará. O guia de estimativa de capacidade mostra o que uma máquina pequena faz; um servidor com vários discos rápidos e muita memória faz muito mais. Antes de distribuir qualquer coisa, verifique, em ordem, três passos mais baratos:
- Índices e consultas. A maior parte da lentidão é um índice ausente ou uma consulta ruim, como mostram as medições acima (160 ms contra 0,1 ms).
- Réplicas de leitura e cache. As leituras costumam dominar; réplicas e um cache as escalam sem mudar o modelo de dados.
- Particionamento dentro de um banco de dados, por tempo ou por locatário, o que mantém pequenos os conjuntos de trabalho.
Só quando as escritas ou os dados excedem uma máquina você precisa de um banco de dados que espalhe os dados entre nós, e então escolhe entre dois caminhos:
- Abrir mão de parte do modelo relacional por um armazenamento chave-valor ou de colunas largas (seção 4), e desenhar seus padrões de acesso em torno da chave de partição.
- Manter o SQL e as transações e pagar pela distribuição. Os sistemas "NewSQL" (o Spanner e seus parentes, entre eles CockroachDB e YugabyteDB) particionam os dados entre máquinas e ainda oferecem SQL com transações distribuídas. O Spanner, por exemplo, usa relógios sincronizados (TrueTime) para dar às transações consistência externa. O preço é a latência: uma transação que precisa ser acordada por réplicas em vários lugares espera uma ida e volta de rede a cada vez, e um desenho que mantém uma transação dentro de uma partição continua muito mais rápido do que um que abrange muitas.
Em qualquer dos casos, a lição do guia de capacidade vale: a escolha decorre dos números (escritas por segundo, tamanho dos dados, distância entre regiões), não da moda.
11. Um conjunto de perguntas para decidir
Percorra-as em ordem. A maioria dos desenhos se resolve nas três primeiras.
Diagram: A decision path for the system of record
- Qual é o sistema de registro, e o que nunca pode estar errado? Escolha o armazenamento em que a correção é mais barata, quase sempre o relacional.
- Quais são os três ou quatro padrões de acesso mais frequentes e mais importantes? Verifique se o candidato responde a cada um por um índice ou uma chave, não por varredura.
- Qual o tamanho e com que velocidade cresce? Faça a aritmética (estimativa de capacidade) antes de dizer "precisamos de escala".
- O que acontece quando surge uma pergunta que você não planejou? Se a resposta é "escrever uma nova tabela e fazer a carga retroativa", tenha certeza de que aceita isso.
- Que consistência cada leitura precisa? O saldo de uma conta precisa estar atual; uma contagem de curtidas pode ter alguns segundos de atraso.
- Quem vai operá-lo, e o que vocês já conhecem? Um banco de dados desconhecido significa falhas desconhecidas às três da manhã.
- Como sair dele? A exportação de dados, a evolução do esquema e a capacidade de reconstruir armazenamentos derivados determinam se uma escolha errada é barata de corrigir.
Decisões trabalhadas
- Uma loja online. Pedidos, estoque, pagamentos e clientes são relacionados, precisam de transações e restrições, e as perguntas não param de mudar: um banco de dados relacional. A busca de produtos começa como o recurso de texto completo do banco e passa para um mecanismo de busca quando o ajuste de relevância importa. As imagens de produtos vão para o armazenamento de objetos. Os relatórios rodam em uma réplica ou em um armazenamento analítico.
- Mensagens de chat. O acesso dominante é "as mensagens mais recentes desta conversa, em ordem", com taxa de escrita e volume muito altos e quase nenhuma junção: um armazenamento de colunas largas ou chave-valor particionado por conversa e ordenado por tempo. Usuários, grupos e cobrança ficam em um banco relacional.
- Análise de produto (bilhões de eventos). Somente inserção, consultado por varredura e agregação de poucas colunas: um armazenamento colunar, alimentado por uma fila. Nunca o banco transacional.
- "Pessoas que você talvez conheça". Consultas de relacionamento de dois ou três saltos cabem em um banco relacional até certo ponto (seção 5); um armazenamento de grafos compensa quando a profundidade cresce ou quando o grafo é o produto.
- Um protótipo com requisitos desconhecidos. Um banco de dados relacional, porque novas perguntas são baratas. O esquema é uma vantagem enquanto você ainda está aprendendo.
12. Tecnologia chata e fichas de inovação
Cada banco de dados que você adiciona traz trabalho operacional (backups, atualizações, monitoramento, conhecimento de plantão), seus próprios modos de falha e suas próprias regras de consistência, e as equipes costumam subestimar isso. "Choose Boring Technology", de Dan McKinley, dá o enquadramento útil: uma equipe tem poucas fichas de inovação, e cada tecnologia nova e não comprovada gasta uma. Gaste-as no que torna o seu produto diferente e use ferramentas bem compreendidas para todo o resto. Um segundo banco de dados precisa, portanto, merecer o seu lugar com uma necessidade medida: uma consulta lenta demais depois de indexada, um volume que o primeiro sistema não aguenta, um recurso que ele não oferece.
Isso não significa "nunca saia do PostgreSQL". Significa que o ônus da prova está no sistema novo, e que a decisão é tomada com números, como os deste guia.
13. Erros comuns
- Escolher por popularidade ou pela última palestra de conferência em vez de pelos padrões de acesso.
- Escolher "sem esquema" para evitar o design. O esquema não desaparece; ele se muda para o código da aplicação, espalhado e sem verificação, e você o reencontra quando documentos antigos têm um formato diferente dos novos.
- Fazer a um armazenamento perguntas para as quais ele não foi moldado e depois culpá-lo: varrer um armazenamento chave-valor, ou consultar documentos aninhados sem índice.
- Usar o cache ou o índice de busca como fonte da verdade. São visões reconstruíveis; se você não consegue reconstruir uma, ela virou um banco de dados sem backup.
- Gravar em dois armazenamentos a partir da aplicação sem uma outbox, confiando que as duas escritas darão certo.
- Supor que existem transações em todo lugar. Verifique os limites do que você usa: itens por transação, se ela atravessa partições ou regiões, se os índices participam.
- Colocar arquivos grandes no banco de dados, ou executar análises pesadas no banco transacional.
- Distribuir cedo demais. Um banco particionado é mais difícil de consultar, alterar e operar; faça isso quando os números exigirem.
- Acreditar em um benchmark que não se parece com a sua carga. As proporções deste guia mudam com o tamanho dos dados, o formato e o hardware; meça com as suas próprias consultas.
14. O que mencionar em uma entrevista
- Comece pedindo os padrões de acesso, a escala e as necessidades de consistência, e diga que a escolha decorre deles.
- Declare um padrão e justifique: relacional como sistema de registro, por causa das transações, das restrições, das consultas ad hoc e dos novos índices baratos.
- Nomeie a troca de cada família em uma frase: chave-valor e colunas largas trocam flexibilidade de consulta e transações por escala; documentos trocam junções pela leitura de um agregado em uma leitura; mecanismos de busca e armazenamentos colunares são visões derivadas; armazenamentos de grafos importam quando a profundidade importa.
- Explique os armazenamentos derivados e a outbox: um único lugar de verdade, e todo o resto reconstruível e eventualmente consistente.
- Use números: uma busca sem índice é uma varredura (ordens de grandeza mais lenta), e o custo de um grafo cresce com os nós alcançados, não com o nome do produto.
- Mencione os limites das transações no armazenamento que você propõe, e o que faria quando uma transação precisa atravessar partições.
- Mostre moderação: fichas de inovação, e quando você separaria um segundo banco de dados (uma necessidade medida, não um palpite).
Resumo rápido
- Escolha pelos padrões de acesso primeiro. Escreva as perguntas, sua frequência e o volume de dados antes de nomear um produto.
- Relacional por padrão para o sistema de registro: transações, restrições, junções e índices que podem ser adicionados depois. Documentos vencem quando você lê um agregado; embuta o que é lido e alterado junto.
- Sem índice correspondente, há varredura em qualquer banco de dados: 160 ms contra 0,1 ms na medição.
- Chave-valor e colunas largas compram escala fixando as perguntas com antecedência e limitando as transações; os armazenamentos de grafos, busca e colunares são estruturas especializadas para perguntas de relacionamento, de texto e de muita varredura.
- Armazenamentos derivados são visões. Grave no sistema de registro, alimente os outros por uma outbox e seja capaz de reconstruí-los.
- Distribua por último: índices, depois réplicas e caches, depois particionamento, depois um banco de dados distribuído.
- Cada novo banco de dados precisa merecer o seu lugar com uma necessidade medida.
Apêndice: o código dos experimentos
Quatro conjuntos de programas produziram os números. orders.sql cria os pedidos como tabelas e como documentos e contém as consultas (meça-as com pgbench -n -T 5 -c 1 -f consulta.sql, usando \set id random(1,1000000) no início de cada arquivo de consulta). graph.sql e bfs.go constroem o grafo de seguidores e o percorrem (exporte as arestas para edges.csv como o comentário em graph.sql indica, e então execute go run . em um diretório com bfs.go renomeado para main.go). fts.sql compara LIKE com uma busca de texto completo indexada por GIN. scan.go compara os layouts por linhas e por colunas em memória. Nos arquivos SQL, as instruções que usam uma variável com dois-pontos (:id, :c, :p, :s, :h, :t, :u) estão escritas como comentários, porque são modelos para o pgbench; remova o -- inicial para usá-las.
orders.sql
-- 1. Orders as tables and as JSON documents. Run with psql -f; about a minute for 1,000,000 orders. Lines starting "-- SELECT" use pgbench variables (:id, :c, :p) and are meant for pgbench.
SET max_parallel_workers_per_gather = 0;
DROP TABLE IF EXISTS order_items, orders, orders_doc;
CREATE TABLE orders (
id bigint PRIMARY KEY, customer_id int NOT NULL, status text NOT NULL, created_at timestamptz NOT NULL, total int NOT NULL DEFAULT 0);
CREATE TABLE order_items (
order_id bigint NOT NULL REFERENCES orders(id), line int NOT NULL, product_id int NOT NULL, qty int NOT NULL, price int NOT NULL,
PRIMARY KEY (order_id, line));
INSERT INTO orders (id, customer_id, status, created_at)
SELECT g, 1 + floor(random() * 100000)::int, (ARRAY['new','paid','shipped','delivered'])[1 + floor(random() * 4)::int],
timestamptz '2026-10-26' - (random() * 365 || ' days')::interval
FROM generate_series(1, 1000000) g;
INSERT INTO order_items (order_id, line, product_id, qty, price)
SELECT o.id, l, 1 + floor(random() * 5000)::int, 1 + floor(random() * 3)::int, 100 + floor(random() * 9900)::int
FROM orders o, LATERAL generate_series(1, 1 + (o.id % 5)::int) l; -- 1 to 5 items, 3 on average
UPDATE orders o SET total = s.t FROM (SELECT order_id, sum(qty * price) t FROM order_items GROUP BY 1) s WHERE s.order_id = o.id;
CREATE INDEX orders_customer ON orders (customer_id);
CREATE TABLE orders_doc (id bigint PRIMARY KEY, doc jsonb NOT NULL);
INSERT INTO orders_doc
SELECT o.id, jsonb_build_object('customer_id', o.customer_id, 'status', o.status, 'created_at', o.created_at, 'total', o.total,
'items', (SELECT jsonb_agg(jsonb_build_object('product_id', i.product_id, 'qty', i.qty, 'price', i.price) ORDER BY i.line)
FROM order_items i WHERE i.order_id = o.id))
FROM orders o;
VACUUM ANALYZE;
-- Indexes added during the measurements (each was timed before and after):
CREATE INDEX od_cust ON orders_doc (((doc->>'customer_id')::int)); -- document: orders of one customer
CREATE INDEX oi_prod ON order_items (product_id); -- tables: lines of one product
CREATE INDEX od_gin ON orders_doc USING gin (doc jsonb_path_ops); -- document: "orders containing product X"
-- Queries, timed with pgbench -n -T 5 -c 1 and a random :id, :c or :p each time
-- SELECT o.*, i.* FROM orders o JOIN order_items i ON i.order_id = o.id WHERE o.id = :id; -- tables, one order
-- SELECT doc FROM orders_doc WHERE id = :id; -- document, one order
-- SELECT id, total FROM orders WHERE customer_id = :c; -- tables, by customer
-- SELECT id, doc->'total' FROM orders_doc WHERE (doc->>'customer_id')::int = :c; -- document, by customer
-- SELECT count(*) FROM order_items WHERE product_id = :p; -- tables, by product
-- SELECT count(*) FROM orders_doc
-- WHERE doc @> jsonb_build_object('items', jsonb_build_array(jsonb_build_object('product_id', :p))); -- document, by product
-- Revenue by product (the whole data set), best of several runs, no parallel workers
SET max_parallel_workers_per_gather = 0;
SELECT product_id, sum(qty * price) r FROM order_items GROUP BY 1 ORDER BY r DESC LIMIT 3;
SELECT (i->>'product_id')::int p, sum((i->>'qty')::int * (i->>'price')::int) r
FROM orders_doc, jsonb_array_elements(doc->'items') i GROUP BY 1 ORDER BY r DESC LIMIT 3;
graph.sql
-- 2. A follower graph: 300,000 users, about 10 follows each (3,000,000 edges). The recursive query at the end uses pgbench variables (:s, :h).
DROP TABLE IF EXISTS follows;
CREATE TABLE follows (src int NOT NULL, dst int NOT NULL, PRIMARY KEY (src, dst));
INSERT INTO follows SELECT DISTINCT s, d FROM (SELECT s, 1 + floor(random()*300000)::int d FROM generate_series(1,300000) s, generate_series(1,10) k) x WHERE s <> d;
VACUUM ANALYZE follows;
SELECT count(*) edges FROM follows;
-- Export the edges for the Go program: psql -Atc "COPY follows TO STDOUT CSV" > edges.csv
-- Everyone within :h hops of user :s (timed with pgbench for h = 2 to 6)
-- WITH RECURSIVE r(n, depth) AS (
-- SELECT :s::int, 0
-- UNION
-- SELECT f.dst, r.depth + 1 FROM r JOIN follows f ON f.src = r.n WHERE r.depth < :h
-- )
-- SELECT count(DISTINCT n) FROM r;
bfs.go
package main
import (
"bufio"
"fmt"
"math/rand"
"os"
"strconv"
"strings"
"time"
)
func main() {
const N = 300001
adj := make([][]int32, N)
f, _ := os.Open("edges.csv")
sc := bufio.NewScanner(f)
t0 := time.Now()
edges := 0
for sc.Scan() {
p := strings.Split(sc.Text(), ",")
a, _ := strconv.Atoi(p[0])
b, _ := strconv.Atoi(p[1])
adj[a] = append(adj[a], int32(b))
edges++
}
fmt.Printf("loaded %d edges in %v\n", edges, time.Since(t0))
for _, h := range []int{2, 3, 4, 5, 6} {
seen := make([]int32, N)
rand.Seed(1)
const runs = 2000
total := 0
t := time.Now()
for i := 1; i <= runs; i++ {
s := int32(1 + rand.Intn(300000))
seen[s] = int32(i)
fr := []int32{s}
cnt := 1
for d := 0; d < h; d++ {
var nx []int32
for _, u := range fr {
for _, v := range adj[u] {
if seen[v] != int32(i) {
seen[v] = int32(i)
nx = append(nx, v)
cnt++
}
}
}
fr = nx
}
total += cnt
}
el := time.Since(t)
fmt.Printf("hops=%d: %.3f ms per query, %d nodes reached on average\n", h, float64(el.Microseconds())/1000/runs, total/runs)
}
}
fts.sql
-- 3. Full-text search over 500,000 documents of 40 words from a skewed 20,000-word vocabulary. The queries that use :t and :u are for pgbench.
DROP TABLE IF EXISTS articles;
CREATE TABLE articles AS
SELECT d AS id, string_agg('word' || wid, ' ') AS body
FROM (SELECT d, 1 + floor(power(random(), 3) * 20000)::int AS wid FROM generate_series(1,500000) d, generate_series(1,40) k) x
GROUP BY d;
ALTER TABLE articles ADD PRIMARY KEY (id);
VACUUM ANALYZE articles;
SELECT count(*) docs, pg_size_pretty(pg_total_relation_size('articles')) size FROM articles;
-- Without an index (term is a random 'word10000'..'word19999', :t is the number)
-- SELECT count(*) FROM articles WHERE body LIKE '%word' || :t || '%';
-- With a stored tsvector and a GIN index
ALTER TABLE articles ADD COLUMN tsv tsvector GENERATED ALWAYS AS (to_tsvector('simple', body)) STORED;
CREATE INDEX articles_tsv ON articles USING gin (tsv);
VACUUM ANALYZE articles;
-- SELECT count(*) FROM articles WHERE tsv @@ to_tsquery('simple', 'word' || :t);
-- Two terms, ranked, best ten
-- SELECT id FROM articles
-- WHERE tsv @@ to_tsquery('simple', 'word' || :t || ' | word' || :u)
-- ORDER BY ts_rank(tsv, to_tsquery('simple', 'word' || :t || ' | word' || :u)) DESC LIMIT 10;
scan.go
package main
import (
"fmt"
"math/rand"
"time"
)
const N = 10_000_000
type Row [10]int64
func best(f func() int64) (time.Duration, int64) {
var b time.Duration = 1 << 62
var r int64
for i := 0; i < 5; i++ {
t := time.Now()
r = f()
if d := time.Since(t); d < b {
b = d
}
}
return b, r
}
func main() {
rows := make([]Row, N)
var cols [10][]int64
for c := range cols {
cols[c] = make([]int64, N)
}
rng := rand.New(rand.NewSource(1))
for i := 0; i < N; i++ {
for c := 0; c < 10; c++ {
v := rng.Int63n(1000)
rows[i][c] = v
cols[c][i] = v
}
}
// Analytics: SUM(c3) WHERE c7 > 900 (touches 2 of 10 columns)
dr, sr := best(func() (s int64) {
for i := range rows {
if rows[i][7] > 900 {
s += rows[i][3]
}
}
return
})
dc, sc := best(func() (s int64) {
a, b := cols[3], cols[7]
for i := range b {
if b[i] > 900 {
s += a[i]
}
}
return
})
fmt.Printf("SUM(c3) WHERE c7>900, %d rows x 10 int64 (%d MB of data)\n row layout: %7.1f ms (%.1f GB/s of memory touched)\n column layout: %7.1f ms -> %.1fx faster, results equal: %v\n",
N, N*80/1_000_000, ms(dr), float64(N*80)/dr.Seconds()/1e9, ms(dc), dr.Seconds()/dc.Seconds(), sr == sc)
// Fetch whole rows by random id (OLTP): 1,000,000 random full-row reads
ids := make([]int, 1_000_000)
for i := range ids {
ids[i] = rng.Intn(N)
}
dr2, a := best(func() (s int64) {
for _, id := range ids {
r := &rows[id]
for c := 0; c < 10; c++ {
s += r[c]
}
}
return
})
dc2, b := best(func() (s int64) {
for _, id := range ids {
for c := 0; c < 10; c++ {
s += cols[c][id]
}
}
return
})
fmt.Printf("fetch all 10 fields of 1,000,000 random rows\n row layout: %7.1f ms\n column layout: %7.1f ms -> row layout %.1fx faster, results equal: %v\n", ms(dr2), ms(dc2), dc2.Seconds()/dr2.Seconds(), a == b)
}
func ms(d time.Duration) float64 { return float64(d.Microseconds()) / 1000 }
Fontes
- Martin Kleppmann, Designing Data-Intensive Applications (O'Reilly, 2017), capítulo 2 "Data Models and Query Languages", capítulo 3 "Storage and Retrieval" (armazenamento por linhas e por colunas, mecanismos estruturados em log) e capítulo 7 "Transactions".
- Dan McKinley, Choose Boring Technology (2015), sobre fichas de inovação.
- Documentação do PostgreSQL: tipos JSON e índices GIN, busca de texto completo e consultas recursivas (WITH).
- Giuseppe DeCandia et al., Dynamo: Amazon's Highly Available Key-value Store, SOSP 2007.
- Fay Chang et al., Bigtable: A Distributed Storage System for Structured Data, OSDI 2006.
- James C. Corbett et al., Spanner: Google's Globally Distributed Database, OSDI 2012 (TrueTime e consistência externa).
- Amazon DynamoDB Developer Guide, Working with transactions (limites de itens e de tamanho, sem transações entre regiões em tabelas globais).
- Alex Petrov, Database Internals (O'Reilly, 2019), sobre mecanismos de armazenamento e transações distribuídas.
Pratique este tema: Databases