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:

PerguntaFormatoFrequência
Mostrar o pedido 8213 com suas linhasbuscar um registro pela chave, com seus filhosmuito alta
Mostrar todos os pedidos do cliente 77listar por um atributo secundárioalta
Reservar o estoque e criar o pedido, ou nenhum dos doisgravar vários registros de forma atômicaalta
Receita por produto no último trimestrevarrer e agregar tudobaixa, mas pesada
Buscar produtos por palavras do nomecorrespondência de texto e ranqueamentoalta
Quem comprou isto também comprou…travessia de relacionamentosmé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:

2. As famílias, em uma tabela

FamíliaOs dados parecemForte emFraca emExemplos típicos
Relacional (SQL)tabelas com colunas tipadas, relacionadas por chavestransações, restrições, junções, consultas ad hocos limites de uma máquina (sem trabalho extra), travessia profunda de grafosPostgreSQL, MySQL
Documentosregistros autocontidos, parecidos com JSONbuscar um agregado inteiro em uma leitura, campos flexíveisjunções e transações entre documentos, análise ad hocMongoDB, Couchbase
Chave-valorum valor opaco atrás de uma chaveas buscas mais simples e rápidas; fácil de particionarqualquer pergunta que não seja "dê-me o valor desta chave"Redis, DynamoDB (uso básico)
Colunas largaslinhas agrupadas por uma chave de partição e ordenadas dentro delavolume enorme de escrita, leituras por intervalo dentro de uma partição, escala horizontalconsultas que não combinam com o desenho de chaves da tabela, junçõesCassandra, Bigtable, DynamoDB
Grafosnós e arestas com propriedadesconsultas de relacionamento com muitos saltosagregação em massa, particionar um grafo muito conectadoNeo4j e similares
Buscaum índice invertido sobre textopalavras, ranqueamento, tolerância a erros de digitação, facetasser a fonte da verdade, transaçõesElasticsearch, OpenSearch, Solr
Séries temporaismedições com carimbos de tempotaxas enormes de inserção, consultas por janela de tempo, retenção, redução de resoluçãoatualizar pontos antigos, consultas de uso geralTimescaleDB, InfluxDB, Prometheus
Colunar / analíticoa mesma tabela, armazenada por colunavarrer e agregar poucas colunas de bilhões de linhasleituras e atualizações de uma linhaClickHouse, BigQuery, Redshift
Armazenamento de objetosarquivos (blobs) por nomearmazenamento barato e durável de coisas grandesconsultas dentro dos arquivos, leituras pequenas de baixa latênciaS3 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:

  1. Transações (ACID): várias mudanças acontecem juntas ou não acontecem, e usuários concorrentes não veem trabalho pela metade.
  2. 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.
  3. 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.
  4. Í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).

PerguntaTabelasDocumentos
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 cliente0,106 ms0,127 ms (índice sobre uma expressão do JSON)
Pedidos de um cliente, sem índice160 ms
Pedidos que contêm um produto, sem índice103 ms1.135 ms
Pedidos que contêm um produto, com índice0,123 ms (B-tree, 20 MB)4,0 ms (índice GIN, 74 MB)
Receita por produto, conjunto de dados inteiro0,52 a 0,56 s2,8 a 3,0 s
Tamanho em disco (dados e índices)418 MB435 MB

Quatro conclusões decorrem daí, e elas são o coração do debate "documento ou relacional":

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:

O que custa:

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.

SaltosUsuários alcançados (média)PostgreSQL, consulta recursivaGo, listas de adjacência em memória
21100,33 ms0,004 ms
31.1081,7 ms0,027 ms
410.88613 ms0,18 ms
591.298120 ms2,0 ms
6285.698919 ms14 ms

Duas lições fáceis de perder:

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:

ConsultaTempo
LIKE '%palavra%', sem índice383 ms
Busca de texto completo com índice GIN, um termo1,7 ms
Busca de texto completo, dois termos com OR, ranqueada, os dez melhores3,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çãoLayout por linhasLayout por colunas
SUM(c3) WHERE c7 > 900 (2 colunas de 10)78 ms26 ms (3,0 vezes mais rápido)
Ler os 10 campos de 1.000.000 de linhas aleatórias47 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

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:

  1. Í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).
  2. Réplicas de leitura e cache. As leituras costumam dominar; réplicas e um cache as escalam sem mudar o modelo de dados.
  3. 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:

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

  1. 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.
  2. 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.
  3. Qual o tamanho e com que velocidade cresce? Faça a aritmética (estimativa de capacidade) antes de dizer "precisamos de escala".
  4. 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.
  5. Que consistência cada leitura precisa? O saldo de uma conta precisa estar atual; uma contagem de curtidas pode ter alguns segundos de atraso.
  6. Quem vai operá-lo, e o que vocês já conhecem? Um banco de dados desconhecido significa falhas desconhecidas às três da manhã.
  7. 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

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

14. O que mencionar em uma entrevista

Resumo rápido

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

Pratique este tema: Databases

Mais guias