EDSQLite Baixar grátis
v0.9 · pré-lançamento

O banco de dados embutido, reescrito do zero em Rust.

Inspirado no SQLite, com JOINs, agregação, subconsultas, transações que sobrevivem a quedas de energia e modo WAL. Um único arquivo, sem servidor.

Baixar para macOS e Linux Ver o roadmap
Grátis macOS · Linux ~600 KB Atualizado em

[ 01 / Resposta rápida ]

O que é o EDSQLite?

O EDSQLite é um banco de dados relacional embutido, inspirado no SQLite e escrito do zero em Rust. O banco inteiro fica num único arquivo e roda dentro do programa, sem servidor. Ele segue a arquitetura do SQLite (parser, VM de bytecode, B-tree e pager) e dá os mesmos resultados que o SQLite 3.53 no SQL que implementa, conferido em mais de 8 milhões de consultas. A versão atual, 0.9, é um pré-lançamento gratuito para macOS e Linux.

Categoria
Banco de dados relacional embutido
Linguagem
Rust, sem unsafe
Versão
0.9.0 (pré-lançamento), 25/09/2026
Sistemas
macOS (Apple Silicon e Intel), Linux (x86_64 e ARM64)
Preço
Gratuito, sem conta
Referência
Resultados conferidos com o SQLite 3.53
Autor
Ederson Melo, edgo

[ 02 / Status ]

O EDSQLite já é estável?

Dá para usar, mas ainda não é uma versão estável. A 0.9 serve para experimentar, aprender e trabalhar com dados que você pode recriar. Para dados que não podem ser perdidos, espere a v1.0: até lá, o formato do arquivo ainda pode mudar, sem migração.

Já dá para confiar

  • SQL do dia a dia: CREATE TABLE/INDEX, INSERT, UPDATE, DELETE e SELECT com WHERE, ORDER BY e LIMIT.
  • JOINs, GROUP BY, HAVING, DISTINCT e subconsultas.
  • Commit atômico mesmo com queda de energia ou kill -9.
  • Várias conexões ao mesmo tempo, com locks e modo WAL.
  • Resultados iguais aos do SQLite em mais de 8 milhões de consultas geradas.

Ainda não

  • Formato de arquivo congelado (chega na v1.0).
  • API para programas, com parâmetros (prepare/bind/step).
  • Restrições, LEFT JOIN, UNION, CASE, CAST, ALTER TABLE e várias funções.
  • Locks no Windows.
  • Fuzzing.

[ 03 / Recursos ]

O que o EDSQLite faz hoje?

Tudo o que está aqui foi comparado com o SQLite de verdade, resultado por resultado.

SQL com os tipos do SQLite

Afinidade por coluna, as cinco classes de valor, aritmética, LIKE, IN, BETWEEN e as mesmas conversões que o SQLite faz.

JOINs e agregação

JOIN ... ON, vírgula e CROSS JOIN, com count, sum, avg, min, max, group_concat, GROUP BY, HAVING e DISTINCT.

Subconsultas

Escalares, IN (SELECT ...) e EXISTS, correlacionadas ou não, em qualquer parte do comando.

Índices e planner

Índices B-tree simples, compostos e UNIQUE. O planner escolhe entre varredura, índice e rowid, e mostra tudo no EXPLAIN QUERY PLAN.

Transações duráveis

BEGIN, COMMIT e ROLLBACK com rollback journal: um crash no meio deixa o banco como estava antes.

Concorrência e WAL

Várias conexões, em threads ou processos, com busy_timeout. No modo WAL, quem lê não bloqueia quem escreve.

[ 04 / Em números ]

Como sabemos que ele dá os mesmos resultados do SQLite?

Com testes diferenciais: SQL gerado ao acaso roda no EDSQLite e no SQLite real, e as respostas precisam ser idênticas, valor por valor e tipo por tipo.

8,5 miconsultas e comandos comparados com o SQLite 3.53
0divergências nos resultados
100%das operações de disco da carga de teste passam por um crash simulado
~600 KBpor binário compactado

Diferencial contra o SQLite

Expressões, índices, JOINs de até três tabelas, agregação, subconsultas e DISTINCT, em milhões de rodadas geradas ao acaso.

Crash em cada operação de I/O

Uma falha simulada em cada escrita e cada fsync: o banco reabre sempre no estado de antes ou de depois da transação.

kill -9 de verdade

Cem rodadas matando o processo no meio de commits, sem nenhuma transação pela metade ou perdida.

Relatórios estilo TPC-H

Consultas de relatório sobre 10 mil itens, com JOIN de três tabelas, HAVING e EXISTS, dão exatamente o resultado do SQLite.

Fonte: suíte de testes do EDSQLite na versão 0.9.0 (setembro de 2026), com o SQLite 3.53.2 como oráculo.

[ 05 / Instalar ]

Como instalar o EDSQLite?

Leva uns dois minutos no terminal.

  1. Baixeo .tar.gz do seu sistema na última versão.
  2. Extraia e instaleo executável edsqlite num diretório do seu PATH.
  3. Abra um bancocom edsqlite dados.db. Sem arquivo, ele usa um banco em memória.
# baixe edsqlite-0.9.0-macos-arm64.tar.gz e então:
tar xzf edsqlite-0.9.0-macos-arm64.tar.gz
sudo mv edsqlite /usr/local/bin/
# o binário não é assinado pela Apple:
xattr -d com.apple.quarantine /usr/local/bin/edsqlite
edsqlite --version

Confira os arquivos com o SHA256SUMS da release: shasum -a 256 -c SHA256SUMS. No REPL, os comandos terminam em ;; também há .tables, .indexes, .headers on e .exit.

[ 06 / Roadmap ]

O que vem por aí?

A próxima parada é a v1.0, a primeira versão estável. Depois, os recursos de SQL que mais fazem falta.

v0.1 – v0.9Concluídas

A base de um banco de dados de verdade

  • Parser, VM de bytecode, B-tree em disco e pager com cache.
  • Tipos com afinidade, índices e query planner.
  • Transações duráveis, concorrência com locks e modo WAL.
  • JOINs, agregação, GROUP BY, HAVING, DISTINCT e subconsultas.
v1.0Próxima

API estável e testes obsessivos

  • Formato do arquivo congelado e documentado, com política de compatibilidade: um banco criado na v1.0 abre nas versões seguintes.
  • API com parâmetros (prepare, bind, step, com ? e :nome), para programas usarem o banco sem montar SQL como texto e sem risco de SQL injection.
  • Fuzzing: SQL arbitrário e arquivos corrompidos, sempre sem travar.
  • Códigos de erro estáveis e recompilação automática quando o schema muda.
  • Queda de energia simulada em toda a suíte de testes, cobertura medida e o corpus de conformidade do SQLite.
  • Opcional: API em C, para usar de outras linguagens.
Depois da v1.0Planejado

Os recursos de SQL que mais fazem falta

  • Restrições: NOT NULL, DEFAULT, INTEGER PRIMARY KEY, CHECK e chaves estrangeiras.
  • Consultas: LEFT JOIN, UNION, CASE, CAST, subconsultas no FROM e WITH.
  • Funções: substr, replace, trim, de data e hora e de janela.
  • Schema: ALTER TABLE, views e COLLATE.
PlataformasPlanejado

Mais sistemas e mais desempenho

  • Windows, com locks entre conexões.
  • Instalação pelo Homebrew e pacotes para Linux.
  • Planner com estatísticas, índices cobertos, VACUUM e transações maiores que a memória.
  • Mais adiante: busca de texto completo, JSON e funções definidas pelo usuário.

[ 07 / Perguntas frequentes ]

Perguntas frequentes sobre o EDSQLite

O que é o EDSQLite?

O EDSQLite é um banco de dados relacional embutido, inspirado no SQLite e escrito do zero em Rust, sem código copiado do SQLite. O banco inteiro fica num único arquivo e roda dentro do programa que o usa, sem servidor.

O EDSQLite é estável? Posso usar em produção?

Ainda não. A versão 0.9 é um pré-lançamento: dá para experimentar, aprender e trabalhar com dados que podem ser recriados. O formato do arquivo ainda pode mudar antes da v1.0, sem migração, então não é recomendado para dados que não podem ser perdidos.

O EDSQLite abre arquivos do SQLite?

Não. O EDSQLite usa um formato de arquivo próprio, inspirado no do SQLite. O que é compatível é a linguagem: o SQL suportado dá os mesmos resultados que o SQLite 3.53, conferido em mais de 8 milhões de consultas geradas.

Quanto custa o EDSQLite?

É gratuito. Os binários para macOS e Linux são baixados diretamente do GitHub Releases, sem conta e sem cadastro.

Em quais sistemas o EDSQLite roda?

macOS (Apple Silicon e Intel) e Linux (x86_64 e ARM64, com binário estático). Windows ainda não tem binário, e os locks entre conexões ainda não existem nele.

Quais recursos de SQL o EDSQLite suporta?

CREATE TABLE, CREATE INDEX, DROP, INSERT, UPDATE, DELETE e SELECT com WHERE, ORDER BY, LIMIT, JOIN, CROSS JOIN, GROUP BY, HAVING, DISTINCT, subconsultas (escalar, IN e EXISTS), agregados (count, sum, total, avg, min, max, group_concat), transações e PRAGMAs de journal e checkpoint. Ainda faltam restrições (NOT NULL, DEFAULT, INTEGER PRIMARY KEY), LEFT JOIN, UNION, CASE, CAST e ALTER TABLE.

Os dados sobrevivem a uma queda de energia?

Sim. Cada commit é atômico, por rollback journal ou pelo modo WAL: um crash no meio deixa o banco como estava antes da transação. Isso é testado com uma falha simulada em cada operação de disco e com o processo morto por kill -9 no meio de commits.

Dá para usar o EDSQLite como biblioteca num programa?

Por enquanto o EDSQLite é distribuído como um executável de linha de comando (um REPL, como o shell do SQLite). A API estável para programas, com parâmetros (prepare, bind, step), é a principal entrega da v1.0.

Qual é a diferença entre o EDSQLite e o SQLite?

O SQLite é o banco embutido de referência, maduro e com décadas de uso. O EDSQLite é uma implementação independente, em Rust, que segue a mesma arquitetura (parser, VM de bytecode, B-tree, pager) e reproduz os resultados do SQLite no SQL que implementa. Ele cobre um subconjunto do SQL e ainda não é estável.

Experimente o EDSQLite

Baixe o binário, abra um banco e rode seu primeiro SELECT. Se encontrar algo estranho, abra uma issue: é assim que a v1.0 fica mais sólida.

Baixar a versão 0.9 Relatar um problema