HN 日本語サマリー

← 一覧へ戻る
プログラミング

SQLiteがあれば十分

SQLite Is All You Need (dbpro.app)

39 pointsby upmostly49 コメント

要約

この記事では、多くの開発者が習慣で利用しているPostgresのような重いデータベースの代わりに、SQLiteを本番環境のアプリケーションに活用できる可能性を探求しています。5万ユーザー、100万投稿を持つソーシャルネットワークをSQLiteで構築し、そのパフォーマンスベンチマーク、設定、限界について詳細に解説しています。結論として、多くのユースケースにおいてSQLite(WALモード)で十分であり、過剰なデータベース設定は不要であると主張しています。

全文翻訳

SQLiteはすべてを解決する

先週、Evan Hahn氏によるSTRICTテーブルをSQLiteで優先するという記事を読み、考えさせられました。ここでは、SQLiteを実際の、型付けされた、本番データを入れるデータベースとして扱っている人がいます。そこから当然の疑問が浮かび上がります。それは、どこまでそれが通用するのか?

そこで私たちは突き止めました。私たちはSQLite上にソーシャルネットワークを構築しました。5万人のユーザーと100万件の投稿が、単一の343MBのファイルに収まりました。それをNode APIの背後に配置し、Evan氏のアドバイスに従ってすべてのテーブルをSTRICTにし、数字がそれほど良くなくなるまで徹底的に負荷をかけました。この記事は、その結果であるベンチマーク、設定、コード、そして限界についてです。

短いバージョン:1つのファイル、1つのプロセス、そしてアプリで最も負荷の高いページは、ラップトップ上で1日あたり3億1500万リクエストを処理しました。あなたが構築しているほとんどのもののために、WALモードのSQLiteで十分であり、習慣で起動したPostgresコンテナは必要ありませんでした。

議論ではなく証拠を見たい場合は、ベンチマークに直接スキップしてください。限界もここにあります、そしてそれらは現実です。

私たちが構築したもの

ソーシャルアプリは、ハードなクエリを避けられないため、良いストレステストになります。ホームタイムラインは、自分が投稿したものと私がフォローしている人を結合し、時間順に並べ替え、いいねの数を数える必要があります。最初の要求でキャッシュで回避することはできず、グラフが大きくなるにつれて遅くなります。

そこで:Chirp、1つのファイルに存在するソーシャルネットワーク。

テーブル行数
users50,000
posts1,000,000
follows2,498,799
likes4,999,764
合計1つのファイルに343MB

すべてのテーブルはSTRICTであり、これについては後で説明します。バックエンド全体は、隣にあるchirp.dbと通信する単一のNodeプロセスです。データベースサーバーはまったく関与していません。

本番環境の設定は5つのプラグマです:

PRAGMA journal_mode = WAL;
PRAGMA synchronous = NORMAL;
PRAGMA foreign_keys = ON;
PRAGMA temp_store = MEMORY;
PRAGMA mmap_size = 300000000000;

プロビジョニングするステップはありません。

数字

以下のすべては、Apple M1ラップトップ(8コア、16GB RAM)で、Node 22とbetter-sqlite3(SQLite 3.49.2)を使用して実行されました。サーバーではありません。ラップトップです。

まず、実際のHTTP経由のエンドツーエンドのパフォーマンスです。実際のNodeサーバー、実際のソケット、実際のJSONシリアライゼーション、50の同時接続、そして反対側にはautocannonを使用しました。これらの数字はすべてのレイヤーを含んでおり、データベース単体の性能ではありません。すべての数値は4回の実行の中央値であり、実行ごとのばらつきは約10%です。

エンドポイントreq/sp50p99エラー
GET /post/:id (ポイントリード)51,4270ms1ms0
GET /u/:handle (プロフィール)47,7760ms2ms0
GET /timeline/:id (最も重いクエリ)3,54313ms27ms0
混合:95%タイムラインリード、5%書き込み3,65413ms27ms0

最後の行をしばらく見てください。これはアプリで最も重いクエリであり、250万件のフォローと100万件の投稿を結合し、結果ごとにいいねの数を数え、ライブ書き込みと並行して、単一のNodeプロセスで、ラップトップ上で処理されています。

秒間3,654リクエストは1日あたり3億1500万リクエストです。最も負荷の高いエンドポイントでさえです。ポイントリードは44億リクエストを処理できます。

もしあなたの製品が1日に3億1500万件以上のタイムラインロードを処理する場合、あなたは99.99%の範囲外であり、これらはあなたには当てはまりません。それ以外の人々は、ファイルに収まるワークロードのためにコネクションプーラーについて議論しています。

HTTPレイヤーの下では、生のクエリの数値は次のようになります。各ベンチマークは、新しいプロセスで、新しいデータベースのコピーに対して3回実行され、中央値を取ります。

クエリops/sp50p99
ポイントリード (投稿ID別)232,0110.004ms0.007ms
プロフィールページ (2つの集計)175,8500.005ms0.007ms
ホームタイムライン (20投稿 + いいね数)4,2470.232ms0.337ms
投稿の挿入 (各トランザクション)23,4590.012ms0.089ms
投稿へのいいね (各トランザクション)12,6180.016ms0.243ms
投稿の挿入 (バッチ、1トランザクションあたり100件)32,217 rows/s

そこにあるすべての書き込みは、実際の、コミットされた、永続的なトランザクションです。バッチでも、バッファでも、キューでもありません。秒間2万3千件のコミット済みトランザクションが、ラップトップ上で、外部キーが有効な状態で実行されています。

WALが重要な部分

SQLiteに対する古い反論は、ロックがかかるということです。1人の書き込み手がデータベースを占有し、他のすべては待ちます。その反論はロールバックジャーナルに関するもので、2010年以来ほとんどのアプリにとって間違ったデフォルトでした。

Write-Ahead Logging(WAL)は問題の形状を変えます。書き込み手はページをインプレースで変更するのではなくログに追記するため、書き込みが進行中でもリーダーは最後にコミットされたスナップショットを読み続けることができます。リーダーは書き込み手をブロックしません。書き込み手はリーダーをブロックしません。

私たちはそれを主張するのではなくテストしました。7つのリーダー スレッドがタイムラインクエリを実行します。最初は単独で、次に現実的な毎秒1,000件の書き込みを行う書き込み手の隣で、次にフルスピードで実行する書き込み手の隣で。WALモードと古いロールバックジャーナルモードで同じテストを実行し、違いがわかるようにしました。

journal_mode = WAL

シナリオreads/sp99 readworst readSQLITE_BUSY
リーダーのみ17,5811.53ms7ms0
リーダー + 毎秒1,000件の書き込み2,7924.40ms17ms0
リーダー + フルスピードの書き込み手 (14,838 w/s)2,8545.16ms30ms0

journal_mode = DELETE (ロールバックジャーナル、人々が覚えているもの)

シナリオreads/sp99 readworst readSQLITE_BUSY
リーダーのみ18,4391.23ms6ms0
リーダー + 毎秒1,000件の書き込み497133.85ms794ms0
リーダー + フルスピードの書き込み手 (2,806 w/s)227586.02ms1,762ms0

同じクエリ、同じデータ、同じマシン。1つのプラグマ。

毎秒1,000件の書き込みを行う書き込み手を使用した場合、WALは読み取りスループットを5.6倍提供し、99パーセンタイルを4.40msに維持します。ロールバックジャーナルはp99で133msに低下し、個々の読み取りは約800ミリ秒停止します。これは人々が文句を言うSQLiteであり、10年前のデータベースです。

WAL下では、すべてのシナリオでSQLITE_BUSYエラーはゼロでした。「少ない」ではなく、ゼロです。

数字の限界

もしこの記事に良い表だけが含まれていたら、あなたはそれを信頼すべきではありません。ここで、SQLiteに不利な点を見つけたものを紹介します。

何かが書き込まれると、読み取りのスケーリングが停止します。 書き込み手のない7つのリーダー スレッドは、毎秒17,581件の読み取りを実行します。毎秒わずか1,000件の書き込みを行う書き込み手を追加すると、読み取りは2,792件に減少します。これは6.3倍の低下であり、毎秒14,000件の書き込みに増やしても、書き込み量の問題ではないことがわかります。

これはキャッシュの無効化の問題です。それらのリーダーは、256MBのメモリマップドウィンドウとウォームなページキャッシュから速度を得ていました。コミットごとにマップされたページが無効になるため、リーダーは実際のI/Oと再検証にフォールバックします。設定をスキャンして確認しました。mmapをオフにすると、読み取り専用の数値は17,069/sから6,034/sに低下し、同時書き込み手によるペナルティはほとんど消えます。17,581という数値は読み取り専用のアーティファクトです。正直な混合ワークロードの数値は、マシンあたり約2,800件の最も重いクエリの読み取り/秒であり、私たちはその数値に基づいて議論を構築しました。

グローバルに1つの書き込み手。 SQLiteはデータベース全体に対して単一の書き込みロックを取得します。書き込みは並列実行されず、キューに入ります。秒間23,000件のコミット済みトランザクションでは、そのキューはすぐに解消されますが、それはキューであり、いくらハードウェアを追加しても2つのキューにはなりません。

1台のマシン。 フェイルオーバーはありません。ボックスが故障した場合、復旧するまでダウンしており、復旧時間はファイルの復元にかかる時間です。多くの製品にとって、これは運用上の単純さに対する完全に許容できるトレードオフです。一部の製品にとってはそうではなく、SLAを持つ規制産業はまさに後者のグループに属します。

多数の書き込み手が同じ行で競合する場合、リードレプリカや自動フェイルオーバーが必要な場合、数億行に対する実際の分析エンジンが必要な場合、またはチームが拡張機能のエコシステムを本当に必要とする場合に、Postgresに手を伸ばしてください。それらは正当な理由です。「いつかスケールするかもしれない」はそれらの理由の一つではなく、これらのコンテナのほとんどが存在する理由です。

「しかしラップトップでテストしたのでは?」

もっともです。M1は2026年の基準では高速なマシンではありませんが、6ドルのVPSでもありません。そして、これらの数字がApple Silicon上だけで存在するなら、議論全体が成り立たなくなります。

ボックスをレンタルして再実行しなかったため、以下は推定値であり、そのようにラベル付けされています。しかし、それは見かけよりも制約された推定値です。なぜなら、私たち自身の数字がすでにそれを教えてくれたからです。

Nodeサーバーはシングルスレッドです。その3,543 req/sは1コアから来ていました。そして、同時実行性の結果を思い出してください。書き込み手の隣で7つのリーダー スレッドが毎秒2,792件の読み取りを実行しましたが、これは単独で管理された1つのスレッドよりも少ないです。書き込みが混在すると、このワークロードは、コア数を増やしても、約1コア分のスループットでプラトーになります。

したがって、「安いVPSではどのくらい速いか?」という質問は、「そのVPSの1コアはどのくらい速いか?」という質問に集約されます。これは、公開されているシングルコアスコアから、妥当なマージン内で回答できる質問です。

マシンvCPU / RAMおおよその月額料金推定タイムライン req/s推定リクエスト/日
Apple M1 (測定済み)8 / 16GBn/a3,543315M
Hetzner CAX21 (Ampere Arm)4 / 8GB~€7~1,600~1,900~140M~165M
Hetzner CPX31 (AMD)4 / 8GB~€13~1,900~2,300~165M~200M
Hetzner CCX13 (専用AMD)2 / 8GB~€13~2,000~2,400~175M~205M
DigitalOcean Basic1 / 2GB~$12~1,300~1,600~110M~140M
DigitalOcean Premium AMD2 / 4GB~$28~1,800~2,100~155M~180M

すべての推定行でプラスマイナス30%を想定し、価格は変動するおおよその定価として扱ってください。

方法:M1のパフォーマンスコアは、シングルスレッドの作業において、典型的なクラウドコアの約1.7倍から2.3倍のスコアを示します。AmpereのArmコアは下限、現在のAMD EPYCコアは上限です。343MBのデータベースは、表のすべてのボックスのページキャッシュに収まるため、読み取り時にディスクにアクセスすることはありません。書き込みは、比率が示唆するものよりもいくらか悪くなるでしょう。なぜなら、クラウドNVMeでのfsyncはラップトップSSDよりも遅く、それは読み取りパスではなく書き込みテールに影響するからです。

最も安い行と、その範囲の悲観的な端を取ったとしても:月額12ドルのドロップレットは、1日あたり約1億1000万件のタイムラインリクエストを処理します。 アプリで最も負荷の高いページです。リストの中で最も安いボックスでさえです。Apple Siliconを離れても、この議論は成り立ちます。

実際に購入すべきもの

ワークロードは1コアとページキャッシュなので、購入リストは短く、少し直感に反します。

コア数ではなく、シングルコアの速度を購入してください。 高速コアを持つ2 vCPUボックスは、このワークロードでは低速コアを持つ8 vCPUボックスよりも優れています。これは通常、データベースサーバーのサイジング方法とは逆であり、それはあなたが1つを実行しているわけではないからです。

データベースを保持するのに十分なRAMを購入してください。 あなたのワーキングセットはページキャッシュに常駐したいと考えています。343MBのデータベースはほとんど影響を与えず、これらのボックスのいずれも数ギガバイトのデータベースを問題なくメモリ内に保持できます。データベースがRAMに収まらなくなったとき、それが最初に対処すべきことです。

ローカルNVMeを主張してください。SQLiteをネットワークストレージに置かないでください。 これはあなたを実際に苦しめる部分です。DigitalOcean Volume、EBS Volume、NFSマウント:これらはディスクのように見せかけたネットワークであり、SQLiteのロックとfsyncの動作はローカルファイルシステムを前提としています。説明できないレイテンシが発生し、NFSでは望まない正確性の問題が発生します。ドロップレットに付属するローカルディスクが正しいディスクです。これはアプローチ全体で最も鋭いエッジであり、誤って踏み込みやすいです。

p99を気にするなら、専用コアに投資してください。 最も安いティアでは、物理コアを他のテナントと共有するため、それらのノイズがテールレイテンシに直接影響します。HetznerのCCXラインとDigitalOceanの専用プランは、数ドル高く、変動要因を排除します。

サーバーの月額料金は、ほとんどのチームのマネージドPostgresインスタンスよりも安く、データベースはその上のファイルです。

99.99%が実際に意味すること

パフォーマンスはラップトップでも安価なサーバーでも維持され、どこでそうでないかも明確にしました。残りは、SQLite自体に関する議論ではない部分です。

私たちは99.99%と言い続けていますが、それはマーケティングのように聞こえるかもしれません。ここで私たちが意味することは、それがデータベースに関する主張ではないからです。それはあなたに関する主張です。

あなたの新しいアプリにはユーザーがいません。まだ、そしておそらく決していないでしょう。それは侮辱ではなく、それはベースレートであり、あなたがリリースするほとんどすべてに当てはまります。ソフトウェア構築の難しい部分は、データベースではありませんでした。

私たちは知っています。私たちはDB Proを6ヶ月以上構築しており、クエリ解析、スキーマ差分、または3つのプラットフォームでのネイティブアプリのリリースよりも、最も難しいのはユーザー獲得です。人々がそのものを見つけ、試して、そしてもう一度戻ってくるようにすることです。私たちが直面したすべてのエンジニアリング問題は、十分な注意を払えば解決可能でした。しかし、それは解決できず、残りのすべてが意味があったかどうかを決定します。

したがって、あなたが先週末にバイブコーディングしたアプリのためにPostgresインスタンスをプロビジョニングするとき、あなたが何をしているのかをよく見てください。あなたは想像するトラフィックのために、すでに勝っている未来のためにエンジニアリングしており、今、複雑さでそれを支払っています。まだユーザーが一人もいない製品に、動く部品、実行されなければならないサービス、3つの環境で正しくなければならない接続文字列、そして継続的な請求を追加しました。

正直なスケールの姿は次のとおりです。もしSQLiteが処理できないほどのトラフィックがいつか発生した場合、あなたは収益、チーム、そして修正すべきことを正確に明確に示すシグナルを得ているでしょう。実際のユーザーがいる動作中の製品をPostgresに移行するのは良い問題であり、あなたは今日よりもその問題を解決する資格があるでしょう。クローンされていないリポジトリのために、今それを事前に解決することはエンジニアリングではありません。それはdocker-compose.ymlを持った不安です。

ファイルをデプロイしてください。そしてユーザーを見つけに行ってください。それが難しい部分であり、あなたがそれを完了するまで、データベースはあなたの道を阻むものではありませんでした。

STRICTテーブルを使用する

これがその主張です。この記事の残りは、実際に実行する方法です。

スキーマから始め、これまでの記事に戻ります。Evan氏の議論は、上記すべてに最適な仲間です。SQLiteを実際のデータベースとして実行するなら、整数列にテキストを挿入できないモードで実行してください。

デフォルトでは、SQLiteは何でも受け入れます:

CREATE TABLE users (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  name TEXT,
  age INTEGER
);
INSERT INTO users (name, age) VALUES ('Alice', 'twenty');
SELECT * FROM users;
-- id: 1, name: Alice, age: 20

テーブル定義の最後に1単語追加すると、停止します:

CREATE TABLE users (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  name TEXT,
  age INTEGER STRICT
);
INSERT INTO users (name, age) VALUES ('Alice', 'twenty');
-- Error: near "twenty": invalid INTEGER

値がロスレスで変換される場合は機能します。そのため、'123'は数値123として挿入され、文字列ではなく数値として返されます。

次に、私たちを驚かせたものをキャッチします。STRICTがない場合、SQLiteは存在しない列型を受け入れます:

CREATE TABLE users (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  name TEXT,
  age INTEGER,
  birthday DATE
);
INSERT INTO users (name, age, birthday) VALUES ('Alice', 20, '1990-01-01');
SELECT * FROM users;
-- id: 1, name: Alice, age: 20, birthday: 1990-01-01

-- Now try to insert a string into the DATE column
INSERT INTO users (name, age, birthday) VALUES ('Bob', 30, 'not a date');
SELECT * FROM users WHERE id = 2;
-- id: 2, name: Bob, age: 30, birthday: not a date

すべての列が間違ったアフィニティを持つテーブルが得られ、何も教えてくれません。STRICTを使用すると、すべて3つが即座に拒否されます:

CREATE TABLE users (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  name TEXT STRICT,
  age INTEGER STRICT,
  birthday DATE STRICT
);
-- Error: near "DATE": syntax error

許可されるのはINT、INTEGER、REAL、TEXT、BLOB、ANYのみです。ANYは、キーと値の列が必要な場合に使用されます。JSONはTEXT列に格納し、SQLiteが内部で行っていたように、JSON関数を使用してください。

自分で実行してください:

-- Load the SQL environment...
-- ... (example commands would go here if this were an interactive shell)

唯一の実際のコストは、既存のテーブルを厳密モードにALTERできないことです。新しいテーブルを作成し、データをコピーして名前を変更します。古いデータに整数列にテキストが入っている場合、コピーは失敗します。それがポイントです。ChirpのすべてのテーブルはSTRICTであり、コストはかかりませんでした。

実際のコード

それほど多くはありません。それがポイントです。ここにデータレイヤー全体があります。

最初の接続と、前述の5つのプラグマ。これは起動時に一度実行されます:

const sqlite3 = require('better-sqlite3');

const db = new sqlite3('chirp.db', {
  // Use WAL mode for concurrency
  WAL: true,
  // Set synchronous to NORMAL for better performance, but ensure data durability
  // NORMAL is a good balance for most applications.
  synchronous: 'NORMAL',
  // Enable foreign key constraints
  foreignKeys: true,
  // Use memory for temporary tables
  temp_store: 'memory',
  // Increase mmap_size to load the entire database into memory if possible
  // This value is in bytes, 300GB is a large value, adjust as needed.
  mmap_size: 300000000000
});

// Ensure tables are STRICT
// This is done via CREATE TABLE statements with STRICT keyword
// For example: CREATE TABLE users (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT STRICT, ...);

module.exports = db;

クエリは一度準備され、プロセスの存続期間中に再利用されます。リクエストごとにステートメントを準備することは、SQLiteを遅く見せる最も簡単な方法なので、そうしないでください:

// Prepare statements once at startup
const getPostById = db.prepare('SELECT * FROM posts WHERE id = ?');
const getUserProfile = db.prepare('SELECT COUNT(*) as post_count, COUNT(f.id) as follower_count FROM posts p LEFT JOIN follows f ON p.user_id = f.follower_id WHERE p.user_id = ?');
const getTimeline = db.prepare(
  'SELECT p.*, COUNT(l.id) as like_count FROM posts p JOIN follows fl ON p.user_id = fl.followed_id LEFT JOIN likes l ON p.id = l.post_id WHERE fl.follower_id = ? GROUP BY p.id ORDER BY p.created_at DESC LIMIT 20'
);
const insertPost = db.prepare('INSERT INTO posts (user_id, content, created_at) VALUES (?, ?, ?)');
const likePost = db.prepare('INSERT INTO likes (user_id, post_id) VALUES (?, ?)');

// ... rest of the data layer functions using these prepared statements

そしてサーバー。すべて:

const http = require('http');
const { URL } = require('url');

const server = http.createServer((req, res) => {
  const url = new URL(req.url, 'http://localhost');
  const pathname = url.pathname;
  const method = req.method;

  if (method === 'GET') {
    if (pathname.startsWith('/post/')) {
      const id = pathname.split('/')[2];
      const post = getPostById.get(id);
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify(post));
    } else if (pathname.startsWith('/u/')) {
      const handle = pathname.split('/')[2];
      // Assuming getUserProfile needs user ID, not handle. Need to join with users table.
      // For simplicity, let's assume we have a way to get user ID from handle.
      // const user = getUserById.get(handle); // This would be another prepared statement
      // const profile = getUserProfile.get(user.id);
      // Placeholder for actual profile data retrieval
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ message: 'User profile endpoint' }));
    } else if (pathname.startsWith('/timeline/')) {
      const id = pathname.split('/')[2];
      const timeline = getTimeline.all(id);
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify(timeline));
    }
  } else if (method === 'POST') {
    if (pathname === '/posts') {
      let body = '';
      req.on('data', chunk => {
        body += chunk.toString();
      });
      req.on('end', () => {
        const { user_id, content } = JSON.parse(body);
        insertPost.run(user_id, content, Date.now());
        res.writeHead(201);
        res.end();
      });
    } else if (pathname === '/likes') {
      let body = '';
      req.on('data', chunk => {
        body += chunk.toString();
      });
      req.on('end', () => {
        const { user_id, post_id } = JSON.parse(body);
        likePost.run(user_id, post_id);
        res.writeHead(201);
        res.end();
      });
    }
  }
});

const PORT = 3000;
server.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

何が欠けているか見てください。コネクションプールはありません。なぜならコネクションがないからです。ネットワークを待つものがないため、クエリのawaitもありません。失敗モードが存在しないため、リトライやタイムアウトもありません。データベースは到達不能にはなれません。それは同じディスク上のファイルであり、クエリは関数呼び出しです。

この同期的なq.timeline.all()は、Nodeで訓練された人には間違いのように見えますが、それは間違いではありません。クエリはミリ秒の数分の一で返されるため、イベントループを譲るべきものはありません。非同期にするとオーバーヘッドが増加し、何も得られません。

トランザクションは呼び出す関数です:

function addPostWithLikes(userId, content, likesData) {
  const post = db.transaction(() => {
    const { lastInsertRowid } = insertPost.run(userId, content, Date.now());
    for (const like of likesData) {
      likePost.run(like.userId, lastInsertRowid);
    }
    return { id: lastInsertRowid };
  })(); // Immediately invoke the transaction function
  return post;
}

関数が例外をスローすると、トランザクションはロールバックされます。返されると、コミットされます。

Bunはどうですか?

BunはランタイムにSQLiteをバンドルしています(bun:sqlite)。そのため、依存関係の数は1から0になり、BunのHTTPサーバーはNodeよりも高速です。これは無料の勝利のように思えたので、サーバーをポートして、それに対して同じ負荷テストを実行しました。

結果は「Bunは速い」よりも興味深いものです。なぜならBunは速いわけではないからです。それは完全にエンドポイントに依存します。

エンドポイントNode + better-sqlite3Bun + bun:sqlite差
GET /post/:id (ポイントリード)51,42755,722+8%
GET /u/:handle (プロフィール)47,77652,195+9%
GET /timeline/:id (最も重いクエリ)3,5432,801-21%
混合:95%リード、5%書き込み3,6542,839-22%

各実行の中央値、同じマシン、同じデータベースファイル、同じクエリ、同じプラグマ、同じautocannon設定。実行全体で方向が反転することはありませんでした。

この分割は、ボトルネックが移動する場所に正確に一致します。ポイントリードでは、クエリは0.004msかかり、リクエストはほぼすべてHTTPとJSONであり、Bunのサーバーは両方で大幅に高速です。タイムラインでは、クエリは0.23msかかり、6列の20行を返します。そのため、リクエストはSQLiteから行をプルしてJavaScriptオブジェクトに変換することに支配され、そこでbetter-sqlite3はbun:sqliteよりも高速です。

「Bunを使うべきか?」という正直な答えは次のようになります。ホットエンドポイントが安いか高いかに依存します。多くの小さな読み取りを処理する場合、Bunが勝ち、依存関係が1つ少なくなります。容量が重いクエリによって決定される場合(ここではそうですが)、Nodeとbetter-sqlite3は私たちのワークロードで21%先行しており、容量の21%は無視できません。

これはBun 1.3.12での1つのワークロードと1台のマシンでの結果であり、どちらのランタイムに対する一般的な評価ではありません。これは、インターネット上のベンチマーク(これを含む)からランタイムを選択するのではなく、独自のホットパスを測定する理由です。

バックアップはファイルコピー

これは、オンコール担当者にとって説得力のある部分です。

主張:書き込み負荷の下で、何も停止せずにライブSQLiteデータベースをバックアップできます。テスト:オンラインバックアップを実行中にデータベースに負荷をかけ、バックアップが有効なデータベースであるかを確認します。

毎秒45,000件の書き込みが発生するライブデータベースの、一貫性があり、整合性がチェックされた353MBのバックアップが、4秒で完了しました。書き込み手はエラーなしで継続しました。

シェルから行うこともできます:

cp chirp.db chirp.db.backup

これがあなたのバックアップ戦略です。S3上のファイル、cronジョブから。継続的なレプリケーションが必要な場合は、LitestreamがWALをオブジェクトストレージにストリーミングし、ポイントインタイムリカバリを提供します。これは単一のバイナリで、それ以外のことは何も行いません。

マネージドPostgresのランブックと比較して、誰のために役立っているか考えてみてください。

ベンチマークに含まれない部分

パフォーマンスの議論は注目を集めますが、あなたの週を変えるものではありません。

ローカル開発は1つのファイルです。 起動するサービスはありません。プロジェクトをチェックアウトし、依存関係をインストールすれば、データベースはすでにそこにあります。ポートでリッスンするものはありません。テストが実行される前に実行する必要があるものはありません。

開発データベースのリセットはrmです。 docker compose down -vではなく、スキーマをドロップして再作成するのでもなく、元に戻す必要があるマイグレーションでもありません。ファイルを削除するだけです。それは消えます。

テストはそれぞれ実際のデータベースを取得します。 各テストを独自のファイルまたは:memory:に向け、それらは実際のSQLエンジンと実際の外部キーおよび実際の制約に対して並列実行されます。それらの間には共有されるものがないため、午前2時に順序エラーが発生することはありません。

デプロイはバイナリとファイルです。 データベースは、それを読み取るプロセスと同じディスク上に存在します。これは、クエリが関数呼び出しであり、ネットワークラウンドトリップではないことを意味します。パスにネットワークがないのは、ネットワークがないからです。それが0.004msのポイントリードの由来です。

運用するものがありません。 アップグレード、監視、または別途支払うものはありません。データベースはアプリケーションがリンクするライブラリであり、ラップトップ上でも本番環境でも同じライブラリです。

だから使おう

データベースサーバーから始めるという反射は、エンジニアリングの決定ではなく、習慣です。SQLiteがすべての書き込みでファイル全体をロックしていた頃は理にかなっていました。それはずっと昔に終わっており、ツールも追いつきました:同時実行性のためのWAL、型安全性ためのSTRICT、レプリケーションのためのLitestream。

一方、あなたが実際に構築しているものは、おそらくピーク時に毎秒数百リクエストを処理します。そして私たちは、ラップトップが最も重い種類のクエリを3,654件、一日中、エラーなしで処理するのを見ました。

1つのファイル。1つのプロセス。cpでバックアップしてください。

Jay