【入門】RustでSQLiteを扱う基本

By /

はい、承知いたしました。RustでSQLiteを扱う基本について、詳細な説明を含む約5000語の記事を記述します。

【入門】RustでSQLiteを扱う基本

はじめに

現代のソフトウェア開発において、データの永続化は不可欠な要素です。様々なデータベースが存在する中で、軽量で組み込みやすく、設定不要なSQLiteは、特にデスクトップアプリケーション、モバイルアプリケーション、組み込みシステム、あるいは小規模なバックエンドサービスなど、幅広い用途で利用されています。

一方、Rustは安全性、速度、並行性を重視したシステムプログラミング言語として注目されています。所有権システムによるメモリ安全性保証や、アクターモデルなどを用いた効率的な並行処理は、堅牢で高性能なアプリケーション開発を可能にします。

Rustの持つ信頼性とパフォーマンス、そしてSQLiteの持つ手軽さと柔軟性を組み合わせることで、非常に強力なアプリケーションを開発することができます。本記事では、Rustを用いてSQLiteデータベースを操作するための基本的な手順と概念を、初心者の方にも理解できるように詳細に解説します。

この記事の対象読者は、Rustの基本的な文法（変数、関数、構造体、Result型、エラーハンドリングなど）を理解している方です。SQLite自体について深く知っている必要はありませんが、リレーショナルデータベースの基本的な概念（テーブル、行、列、SQL文など）に触れたことがあると、よりスムーズに理解できるでしょう。

この記事を読むことで、以下のことができるようになります。

  • RustプロジェクトにSQLiteを扱うためのクレートを追加する。
  • SQLiteデータベースファイルへの接続を開く・閉じる。
  • SQL文（CREATE TABLE, INSERT, SELECT, UPDATE, DELETE）を実行する。
  • プリペアドステートメントを用いて安全かつ効率的にクエリを実行する。
  • クエリ結果を取得し、Rustのデータ型にマッピングする。
  • トランザクションを用いて複数の操作を原子的に実行する。
  • 発生しうるエラーを適切に処理する。

それでは、早速始めていきましょう。

SQLiteとは？

Rustでの具体的な操作に入る前に、SQLiteについて少し掘り下げてみましょう。SQLiteは、C言語で書かれた組み込み型のリレーショナルデータベースエンジンです。その最大の特徴は、以下の点にあります。

  • サーバーレス: 従来のデータベース（PostgreSQL, MySQLなど）は、クライアント・サーバーモデルで動作し、データベースサーバーを別途インストール・実行する必要があります。SQLiteはアプリケーション内にライブラリとして組み込まれ、直接データベースファイル（通常は単一のファイル）にアクセスします。これにより、設定や管理の手間が大幅に削減されます。
  • 自己完結型: 外部依存性がほとんどありません。必要なコードはすべてライブラリ内に含まれています。
  • 設定不要: インストールや設定ファイルの設定といった作業が不要です。データベースファイルを作成するか、既存のファイルを開くだけで利用できます。
  • トランザクション: ACID特性（原子性 Atomicity, 一貫性 Consistency, 独立性 Isolation, 持続性 Durability）を満たすトランザクションを完全にサポートしています。これにより、データの整合性を保ちながら安全に操作を行うことができます。
  • 軽量: 非常に小さなフットプリントで動作し、メモリ消費も抑えられています。

これらの特徴から、SQLiteは組み込みアプリケーションやテスト用途、単一ユーザーのデスクトップアプリケーション、または設定を最小限に抑えたい場面などで非常に有効な選択肢となります。Rustのようなコンパイル言語と組み合わせることで、配布時に別途データベースサーバーをインストールする必要がない、完全に自己完結した実行可能ファイルを生成できるという大きな利点があります。

RustでSQLiteを扱うための準備

RustでSQLiteを扱うための主要なクレートは rusqlite です。このクレートは、SQLiteのCライブラリに対する安全なバインディングを提供し、RustらしいAPIでデータベース操作を行うことができます。

まずは、新しいRustプロジェクトを作成しましょう。ターミナルを開いて、以下のコマンドを実行します。

bash
cargo new rust_sqlite_example
cd rust_sqlite_example

次に、プロジェクトに rusqlite クレートへの依存関係を追加します。Cargo.toml ファイルを開き、[dependencies] セクションに以下の行を追加してください。

toml
[dependencies]
rusqlite = "0.30.0" # バージョンは最新のものを使用することをお勧めします

執筆時点（2023年末〜2024年初頭）では 0.30.0 あたりが最新ですが、今後変更される可能性があります。cargo add rusqlite コマンドを使うと、常に最新バージョンを追加できます。

これで、プロジェクトで rusqlite を使用する準備が整いました。

データベースへの接続

SQLiteデータベースを操作するには、まずデータベースへの「接続」を確立する必要があります。rusqliteでは、rusqlite::Connection 構造体がこの接続を表します。

接続を開く方法はいくつかあります。最も一般的なのは、ファイルパスを指定する方法と、インメモリデータベースを使用する方法です。

ファイルベースのデータベースへの接続

ファイルベースのデータベースは、実際のファイルシステム上のファイルとしてデータを永続化します。指定したファイルが存在しない場合は新規に作成されます。

src/main.rs ファイルを開き、既存のコードを以下の内容に置き換えてください。

“`rust
use rusqlite::{Connection, Result};

fn main() -> Result<()> {
// データベースファイルへの接続を開く
// 指定したファイルが存在しない場合は新規作成される
let conn = Connection::open(“my_database.db”)?;

println!("データベースに接続しました。");

// ここでデータベース操作を行う

// Connectionオブジェクトがスコープを抜けると、自動的に接続が閉じられる
// 明示的に閉じる必要はないが、閉じることも可能
// conn.close().map_err(|(_, e)| e)?; // close() は Result<(Connection, Error)> を返すため少し注意が必要

Ok(())

}
“`

このコードは非常にシンプルです。

  1. use rusqlite::{Connection, Result}; で必要な型をインポートしています。Result は rusqlite::Result であり、標準ライブラリの std::result::Result をラップしたものですが、多くの場合互換性があります。
  2. Connection::open("my_database.db") は、my_database.db という名前のデータベースファイルへの接続を試みます。
  3. このメソッドは Result<Connection, rusqlite::Error> を返します。接続に成功すれば Ok(Connection)、失敗すれば Err(rusqlite::Error) です。
  4. ? オペレーターを使用することで、エラーが発生した場合に関数から早期リターンしています。main 関数の戻り値型を Result<()> にしているのはそのためです。
  5. 接続が成功すると、conn 変数に Connection オブジェクトが束縛されます。
  6. conn オブジェクトは、Rustの所有権システムによって管理されます。main 関数のスコープの終わりに達すると、conn がドロップされ、データベース接続は自動的に閉じられます。明示的に conn.close() を呼び出すことも可能ですが、通常はDropに任せます。

このコードを実行すると、現在のディレクトリに my_database.db というファイルが作成されます（初回実行時）。

bash
cargo run

出力:
データベースに接続しました。

ファイルエクスプローラーなどで確認すると、my_database.db というファイルができているはずです。

インメモリデータベースへの接続

テスト用途や一時的なデータストアとして、データをファイルに保存せず、完全にメモリ上で管理したい場合があります。SQLiteはインメモリデータベースをサポートしており、rusqlite では特別なファイルパス :memory: を指定することで利用できます。

“`rust
use rusqlite::{Connection, Result};

fn main() -> Result<()> {
// インメモリデータベースへの接続を開く
let conn = Connection::open(“:memory:”)?;

println!("インメモリデータベースに接続しました。");

// ここでデータベース操作を行う

// Connectionオブジェクトがスコープを抜けると、インメモリデータベースは破棄される

Ok(())

}
“`

このコードを実行してもファイルは作成されません。インメモリデータベースはアプリケーションの実行中にのみ存在し、接続が閉じられるとデータは失われます。

本記事では、特に断りがない限りファイルベースのデータベース (my_database.db) を使用して説明を進めます。

テーブルの作成

データベースにデータを保存するには、まずテーブル構造を定義する必要があります。これはSQLの CREATE TABLE 文を使って行います。rusqlite では、Connection オブジェクトの execute メソッドを使ってSQL文を実行できます。

execute メソッドは、INSERT, UPDATE, DELETE, CREATE TABLE, DROP TABLEなどの、結果セットを返さないSQL文の実行に使用します。

main 関数にテーブル作成のコードを追加しましょう。

“`rust
use rusqlite::{Connection, Result};

[derive(Debug)] // デバッグ出力のためにDebugトレイトを導出

struct User {
id: i32,
name: String,
email: String,
}

fn main() -> Result<()> {
let conn = Connection::open(“my_database.db”)?;

// ユーザーテーブルを作成するSQL文
let create_table_sql = "
    CREATE TABLE IF NOT EXISTS users (
        id INTEGER PRIMARY KEY,
        name TEXT NOT NULL,
        email TEXT NOT NULL UNIQUE
    )
";

// SQL文を実行
conn.execute(create_table_sql, [])?; // パラメータは空の配列[]を指定

println!("'users' テーブルを作成または確認しました。");

// 後続の操作を追加...

Ok(())

}
“`

解説：

  1. CREATE TABLE IF NOT EXISTS users (...): CREATE TABLE はテーブルを作成するSQLコマンドです。IF NOT EXISTS を追加することで、もし同じ名前のテーブルが既に存在してもエラーにならないようにします。users は作成するテーブルの名前です。
  2. id INTEGER PRIMARY KEY: id という名前の列を定義します。
    • INTEGER: 整数型を指定します。SQLiteの INTEGER PRIMARY KEY は特殊で、新しい行が挿入されるたびにユニークな値を自動的に生成するROWIDエイリアスとして機能します（AUTOINCREMENTのようなものですが、詳細は異なります）。
    • PRIMARY KEY: この列がテーブルの主キーであることを示します。主キーはテーブル内の各行を一意に識別するために使用されます。
  3. name TEXT NOT NULL: name という名前の列を定義します。
    • TEXT: テキスト文字列を格納します。SQLiteのデータ型は非常に柔軟で、型アフィニティに基づいて格納されます。TEXT にはUTF-8などの文字列が格納できます。
    • NOT NULL: この列にNULL値を挿入することを禁止します。すべての行は name の値を持つ必要があります。
  4. email TEXT NOT NULL UNIQUE: email という名前の列を定義します。
    • UNIQUE: この列の値がテーブル内でユニークでなければならないことを示します。同じメールアドレスを持つユーザーを複数登録できません。
  5. conn.execute(create_table_sql, [])?: execute メソッドを呼び出してSQL文を実行します。
    • 第一引数は実行するSQL文の文字列スライス (&str) です。
    • 第二引数はSQL文中のパラメータ（プレースホルダー）にバインドする値のリストです。今回の CREATE TABLE 文にはパラメータがないため、空の配列 [] を渡します。
    • execute は影響を受けた行数を含む Result<usize, rusqlite::Error> を返します。CREATE TABLE の場合は通常0を返します。? でエラーを処理します。

このコードを実行すると、my_database.db ファイル内に users という名前のテーブルが作成されます。二度目以降の実行では IF NOT EXISTS のおかげでエラーにならず、「’users’ テーブルを作成または確認しました。」と表示されます。

SQLiteのデータ型について補足

SQLiteは、他の多くのデータベースシステムと比較してデータ型システムが柔軟です。SQLiteのデータ型は「ストレージクラス」と呼ばれ、以下の5つがあります。

  • NULL: 値がNULLです。
  • INTEGER: 符号付き整数。1, 2, 3, 4, 6, または8バイトで格納されます。
  • REAL: 浮動小数点数。8バイトのIEEE 754浮動小数点として格納されます。
  • TEXT: テキスト文字列。データベースエンコーディング（UTF-8またはUTF-16）を使用して格納されます。
  • BLOB: バイナリデータ。入力されたまま格納されます。

CREATE TABLE文で指定する型名（INTEGER, TEXT など）は、厳密な型ではなく「型アフィニティ」として機能します。例えば、INTEGER 型アフィニティを持つ列にテキスト文字列を挿入しようとすると、SQLiteは可能な限り型を変換しようと試みますが、変換できない場合はそのままテキストとして格納されることもあります。しかし、一般的には指定した型アフィニティに合ったデータを格納するのが普通です。rusqlite はRustの型とSQLiteの型アフィニティ間のマッピングを提供し、安全なデータ変換を助けてくれます。

データの挿入 (INSERT)

テーブルを作成したら、次にデータを挿入します。データの挿入にはSQLの INSERT INTO 文を使用します。安全かつ効率的にデータを挿入するためには、プリペアドステートメントを使用することが推奨されます。

プリペアドステートメントとは、SQL文のテンプレートを事前にデータベースに準備させておくものです。値の部分はプレースホルダー（? や :param_name など）にしておき、実行時にそのプレースホルダーに実際の値をバインドします。これにより、SQLインジェクション攻撃を防ぎ、同じ構造のSQL文を繰り返し実行する際のパフォーマンスを向上させることができます。

rusqlite では、Connection オブジェクトの prepare メソッドを使ってプリペアドステートメントを作成し、Statement オブジェクトの execute メソッドを使って実行します。

main 関数にユーザーを挿入するコードを追加しましょう。

“`rust
use rusqlite::{Connection, Result};

[derive(Debug)]

struct User {
id: i32,
name: String,
email: String,
}

fn main() -> Result<()> {
let conn = Connection::open(“my_database.db”)?;

let create_table_sql = "
    CREATE TABLE IF NOT EXISTS users (
        id INTEGER PRIMARY KEY,
        name TEXT NOT NULL,
        email TEXT NOT NULL UNIQUE
    )
";
conn.execute(create_table_sql, [])?;
println!("'users' テーブルを作成または確認しました。");

// INSERT 文のプリペアドステートメントを作成
let mut stmt = conn.prepare("INSERT INTO users (name, email) VALUES (?, ?)")?;

// パラメータをバインドしてステートメントを実行
// プレースホルダー (?) に対応する値を配列またはタプルで渡す
stmt.execute(["Alice", "[email protected]"])?;
stmt.execute(["Bob", "[email protected]"])?;

println!("ユーザーデータを挿入しました。");

// 挿入された最新のROWIDを取得 (INTEGER PRIMARY KEYの場合)
let last_insert_rowid = conn.last_insert_rowid();
println!("最新の挿入行のROWID: {}", last_insert_rowid);


Ok(())

}
“`

解説：

  1. conn.prepare("INSERT INTO users (name, email) VALUES (?, ?)")?: prepare メソッドを呼び出して、INSERT 文のプリペアドステートメントを作成します。
    • SQL文中の ? は「位置指定パラメータ」と呼ばれるプレースホルダーです。これらのプレースホルダーには、後で execute メソッドの第二引数で値をバインドします。
    • prepare は Result<Statement, rusqlite::Error> を返します。? でエラー処理し、成功すれば Statement オブジェクトが stmt に束縛されます。Statement オブジェクトは可変 (mut) である必要があります。
  2. stmt.execute(["Alice", "[email protected]"])?: 作成したプリペアドステートメントを実行します。
    • execute メソッドの第一引数は、SQL文中のプレースホルダーに対応する値のリストです。ここでは、? が2つあるので、要素数2の配列 ["Alice", "[email protected]"] を渡しています。最初の ? に "Alice"、二番目の ? に "[email protected]" がバインドされます。
    • execute は影響を受けた行数（usize）を含む Result<usize, rusqlite::Error> を返します。INSERT 文の場合は通常1を返します。
  3. 同じ stmt オブジェクトを使って、異なるパラメータで繰り返し execute を呼び出すことができます。これがプリペアドステートメントの利点の一つです。
  4. conn.last_insert_rowid(): INTEGER PRIMARY KEY 列を持つテーブルに新しい行が正常に挿入された後、その行のROWID（多くの場合は主キーの値と同じになります）を取得できます。これは、新しく挿入した行のIDを知りたい場合などに便利です。

このコードを実行すると、「Alice」と「Bob」という2人のユーザーデータが users テーブルに挿入されます。

名前付きパラメータ

位置指定パラメータ (?) の代わりに、名前付きパラメータ（:param_name や @param_name, $param_name）を使用することもできます。名前付きパラメータは、特にパラメータが多い場合に、どの値がどのプレースホルダーに対応するのかが分かりやすくなるという利点があります。

“`rust
// INSERT 文を名前付きパラメータで作成
let mut stmt_named = conn.prepare(“INSERT INTO users (name, email) VALUES (:name, :email)”)?;

// 名前付きパラメータをバインドして実行
// パラメータ名は接頭辞(: @ $)なしで指定する
stmt_named.execute(&[(“:name”, &”Charlie”), (“:email”, &”[email protected]”)])?;

println!(“Charlieを挿入しました (名前付きパラメータ)。”);
“`

名前付きパラメータを使用する場合、execute メソッドには名前と値のペアのリストを渡します。タプルの形で (":param_name", &value) のように指定します。値は参照 (&) で渡す必要がある点に注意してください。文字列リテラルは &str なのでそのまま渡せますが、String型の変数などを渡す場合は &my_string のようにします。

データの取得 (SELECT)

データベースに格納されたデータを読み出すには、SQLの SELECT 文を使用します。データの取得にもプリペアドステートメントを使用し、Statement オブジェクトの query メソッドを使います。

query メソッドは、結果セットを返す SELECT 文のために使われます。実行すると、Rows オブジェクトを返します。Rows はイテレーターであり、ループを使って結果の各行を順番に処理することができます。

先ほどのコードに、挿入したユーザーデータを読み出す部分を追加しましょう。

“`rust
use rusqlite::{Connection, Result, params}; // params! マクロをインポート

[derive(Debug)]

struct User {
id: i32,
name: String,
email: String,
}

fn main() -> Result<()> {
let conn = Connection::open(“my_database.db”)?;

let create_table_sql = "
    CREATE TABLE IF NOT EXISTS users (
        id INTEGER PRIMARY KEY,
        name TEXT NOT NULL,
        email TEXT NOT NULL UNIQUE
    )
";
conn.execute(create_table_sql, [])?;
println!("'users' テーブルを作成または確認しました。");

// INSERT処理 (前述のコードを参照)
let mut stmt_insert = conn.prepare("INSERT INTO users (name, email) VALUES (?, ?)")?;
// 既にデータが存在する可能性があるので、今回は挿入をスキップするか、エラーハンドリングを工夫する
// 簡単のため、ここでは挿入済みを前提とするか、UNIQUE制約違反は無視する
// 本番コードではINSERTの前にSELECTで存在確認するなど、より丁寧な処理が必要
println!("(INSERT処理はスキップまたはエラー無視)");
// stmt_insert.execute(["Alice", "[email protected]"])?;
// stmt_insert.execute(["Bob", "[email protected]"])?;
// stmt_insert.execute(["Charlie", "[email protected]"])?;


println!("\n--- 全ユーザーデータを取得 ---");

// SELECT 文のプリペアドステートメントを作成
let mut stmt_select_all = conn.prepare("SELECT id, name, email FROM users")?;

// クエリを実行し、結果のイテレーターを取得
let user_iter = stmt_select_all.query([])?; // パラメータがないので空の配列

// 各行をイテレートしてデータを取得
let mut users: Vec<User> = Vec::new();
for row_result in user_iter {
    let row = row_result?; // 各行の結果もResultでラップされているのでアンラップ

    // Rowオブジェクトからカラムの値を取得
    // get() メソッドはカラムのインデックスまたは名前を指定し、取得したい型をジェネリクスで指定する
    let id: i32 = row.get(0)?; // 0番目のカラム (id) をi32として取得
    let name: String = row.get(1)?; // 1番目のカラム (name) をStringとして取得
    let email: String = row.get(2)?; // 2番目のカラム (email) をStringとして取得

    // あるいは、get_unwrap() を使うとResultを返さないが、存在しないカラム指定などでパニックする可能性がある
    // let id: i32 = row.get_unwrap(0);

    users.push(User { id, name, email });
}

// 取得したユーザーデータを表示
for user in &users {
    println!("{:?}", user);
}

Ok(())

}
“`

解説：

  1. conn.prepare("SELECT id, name, email FROM users")?: 全ユーザーを取得するための SELECT 文のプリペアドステートメントを作成します。取得したい列を明示的に指定することが推奨されます (* よりも)。
  2. let user_iter = stmt_select_all.query([])?: プリペアドステートメントに対して query メソッドを呼び出します。SELECT 文にパラメータがないため、空の配列 [] を渡しています。query は Result<Rows, rusqlite::Error> を返します。
  3. let mut users: Vec<User> = Vec::new();: 取得したデータを格納するための User 構造体のベクターを準備します。
  4. for row_result in user_iter: Rows オブジェクトはイテレーターなので、for ループで各行を順番に処理できます。Rows イテレーターは各要素を Result<Row, rusqlite::Error> として返します。データベースからの読み取り中にエラーが発生する可能性があるためです。
  5. let row = row_result?;: 各行の結果 Result<Row, rusqlite::Error> をアンラップします。エラーの場合はループを中断して関数からリターンします。
  6. let id: i32 = row.get(0)?;: Row オブジェクトの get メソッドを使って、カラムの値を取得します。
    • get<I, T: FromSql>(idx: I) -> Result<T, Error> シグネチャを持ちます。
    • I: カラムのインデックス（0から始まる整数）またはカラム名 (&str) を指定できます。ここではインデックス 0 を指定しています。
    • T: 取得したいRustの型を指定します。FromSql トレイトを実装している型を指定できます。一般的な型（i32, i64, f64, String, Vec<u8> (BLOB), Option<T> など）はデフォルトで実装されています。ジェネリクスとして i32 を指定することで、SQLiteのINTEGER値をi32に変換して取得しようとします。
    • get は Result<T, rusqlite::Error> を返します。カラムのインデックスが不正だったり、SQLiteの値を指定されたRustの型に変換できなかったりした場合にエラーになります。
  7. 同様に、カラムインデックス1から name (String)、カラムインデックス2から email (String) を取得します。
  8. 取得した値を元に User 構造体のインスタンスを作成し、ベクターに追加します。
  9. ループが終了すると、users ベクターにはすべてのユーザーデータが格納されています。最後にそれを表示しています。

このコードを実行すると、以下のような出力が得られるはずです（IDは自動採番なので、挿入順によって変わる可能性があります）。

“`
‘users’ テーブルを作成または確認しました。
(INSERT処理はスキップまたはエラー無視)

— 全ユーザーデータを取得 —
User { id: 1, name: “Alice”, email: “[email protected]” }
User { id: 2, name: “Bob”, email: “[email protected]” }
User { id: 3, name: “Charlie”, email: “[email protected]” }
“`

単一の行を取得する (query_row)

SELECT 文がただ1つの行だけを返すことが分かっている場合（例: 主キーで検索する場合）、query メソッドを使ってイテレーター処理を行うよりも、query_row メソッドを使う方が簡潔です。

query_row メソッドは、結果セットをイテレートするのではなく、直接単一の Row オブジェクト、または結果が0行/複数行の場合にエラーを返します。

特定のIDのユーザーを取得する例を見てみましょう。

“`rust
use rusqlite::{Connection, Result, params};

[derive(Debug)]

struct User {
id: i32,
name: String,
email: String,
}

fn main() -> Result<()> {
// … (接続、テーブル作成、INSERT処理は省略) …
let conn = Connection::open(“my_database.db”)?;
// テーブル作成とデータの存在確認（省略）

println!("\n--- 特定のユーザーを取得 (ID=1) ---");

// 特定のIDを持つユーザーを取得するSELECT文 (パラメータ付き)
let mut stmt_select_one = conn.prepare("SELECT id, name, email FROM users WHERE id = ?")?;

// query_row を使って単一の行を取得
// パラメータには取得したいユーザーのID (ここでは 1) を指定
// パラメータを渡すには rusqlite::params! マクロが便利
let user_id_1 = stmt_select_one.query_row(params![1], |row| {
    // クロージャの中でRowオブジェクトを受け取り、Rustの型に変換して返す
    // このクロージャがResult<T, rusqlite::Error> を返す必要がある
    let id: i32 = row.get(0)?;
    let name: String = row.get(1)?;
    let email: String = row.get(2)?;
    Ok(User { id, name, email }) // 成功時はOk(User)を返す
}); // query_row 全体の結果も Result<T, rusqlite::Error> となる

match user_id_1 {
    Ok(user) => println!("{:?}", user),
    Err(rusqlite::Error::QueryReturnedNoRows) => {
        println!("指定されたIDのユーザーは見つかりませんでした。");
    }
    Err(e) => {
        // その他のエラー
        eprintln!("ユーザー取得エラー: {}", e);
        return Err(e); // エラーを上位へ伝播
    }
}

println!("\n--- 存在しないユーザーを取得 (ID=99) ---");

let user_id_99 = stmt_select_one.query_row(params![99], |row| {
    let id: i32 = row.get(0)?;
    let name: String = row.get(1)?;
    let email: String = row.get(2)?;
    Ok(User { id, name, email })
});

match user_id_99 {
    Ok(user) => println!("{:?}", user),
    Err(rusqlite::Error::QueryReturnedNoRows) => {
        println!("指定されたIDのユーザーは見つかりませんでした。");
    }
    Err(e) => {
        eprintln!("ユーザー取得エラー: {}", e);
        return Err(e);
    }
}


Ok(())

}
“`

解説：

  1. conn.prepare("SELECT id, name, email FROM users WHERE id = ?")?: WHERE id = ? という条件付きの SELECT 文を準備します。? は検索したいIDのプレースホルダーです。
  2. stmt_select_one.query_row(params![1], |row| { ... }): query_row メソッドを呼び出します。
    • 第一引数 params![1] は、SQL文中のプレースホルダーにバインドする値のリストです。rusqlite::params! マクロを使うと、可変個引数でパラメータを簡単に指定できます。このマクロは内部的に適切な型に変換してくれます。
    • 第二引数はクロージャです。このクロージャは、クエリが単一の行を返した場合に、その Row オブジェクトを受け取って実行されます。クロージャの目的は、データベースの Row からRustの構造体や値へのマッピングを行うことです。クロージャは Result<T, rusqlite::Error> を返す必要があります。ここで T は最終的に query_row が返す成功時の型になります。
    • クロージャ内部では、前述の get メソッドを使って Row から各カラムの値を取得し、User 構造体を作成しています。成功したら Ok(User { ... }) を返します。
  3. query_row メソッドは、クロージャの結果である Result<T, rusqlite::Error> を返します。
    • クエリが正確に1つの行を返した場合：Ok(T) を返します（T はクロージャが Ok の中にラップして返した型）。
    • クエリが0行を返した場合：Err(rusqlite::Error::QueryReturnedNoRows) を返します。
    • クエリが複数の行を返した場合：Err(rusqlite::Error::QueryReturnedMultipleRows) を返します。
    • その他のデータベースエラーが発生した場合：Err(rusqlite::Error::...) を返します。
  4. 取得結果は match 式を使ってハンドリングしています。成功時はユーザー情報を表示し、QueryReturnedNoRows の場合は「見つかりませんでした」と表示し、その他のエラーの場合はエラーメッセージを表示して関数からリターンしています。

このコードを実行すると、ID=1のユーザーが見つかって表示され、ID=99のユーザーは見つからなかったというメッセージが表示されます。

params! マクロはパラメータを渡す際に非常に便利で、Rustのさまざまな型（整数、浮動小数点数、文字列、バイト列、Optionなど）をSQLiteの適切な型に自動的にバインドしてくれます。

データの更新 (UPDATE)

既存のデータベースレコードを更新するには、SQLの UPDATE 文を使用します。これも結果セットを返さない操作なので、プリペアドステートメントの execute メソッドを使用します。

特定のユーザーのメールアドレスを更新する例を考えましょう。

“`rust
use rusqlite::{Connection, Result, params};

[derive(Debug)]

struct User {
id: i32,
name: String,
email: String,
}

fn main() -> Result<()> {
// … (接続、テーブル作成、INSERT処理、SELECT処理は省略) …
let conn = Connection::open(“my_database.db”)?;
// テーブル作成とデータの存在確認（省略）

println!("\n--- ユーザーデータを更新 ---");

// UPDATE 文のプリペアドステートメントを作成 (パラメータ付き)
let mut stmt_update = conn.prepare("UPDATE users SET email = ? WHERE id = ?")?;

// パラメータをバインドしてステートメントを実行
// 影響を受けた行数が返される
let updated_rows = stmt_update.execute(params!["[email protected]", 1])?;

println!("ID=1 のユーザーのメールアドレスを更新しました。影響を受けた行数: {}", updated_rows);

// 更新されたユーザー情報を再度取得して確認 (前述のquery_rowのコードを再利用)
println!("\n--- 更新後のユーザー情報を確認 (ID=1) ---");
let mut stmt_select_one = conn.prepare("SELECT id, name, email FROM users WHERE id = ?")?;
let user_id_1_updated = stmt_select_one.query_row(params![1], |row| {
    Ok(User { id: row.get(0)?, name: row.get(1)?, email: row.get(2)? })
});
match user_id_1_updated {
    Ok(user) => println!("{:?}", user),
    Err(e) => eprintln!("更新後のユーザー取得エラー: {}", e),
}


Ok(())

}
“`

解説：

  1. conn.prepare("UPDATE users SET email = ? WHERE id = ?")?: UPDATE 文を準備します。SET email = ? で更新する列と新しい値を指定し、WHERE id = ? で更新対象の行を特定します。どちらもパラメータを使っています。
  2. let updated_rows = stmt_update.execute(params!["[email protected]", 1])?;: プリペアドステートメントを実行します。params!["[email protected]", 1] で、一つ目の ? に新しいメールアドレス、二つ目の ? に対象のID（1）をバインドしています。
  3. execute メソッドは、この操作によって影響を受けた行数を返します。この例では、ID=1の行が見つかれば updated_rows は1になります。ID=1の行が存在しなければ、0が返されます。

このコードを実行すると、ID=1のユーザーのメールアドレスが更新され、その後に更新後の情報が取得されて表示されます。

データの削除 (DELETE)

データベースからレコードを削除するには、SQLの DELETE FROM 文を使用します。これも結果セットを返さない操作なので、プリペアドステートメントの execute メソッドを使用します。

特定のユーザーを削除する例を考えましょう。

“`rust
use rusqlite::{Connection, Result, params};

[derive(Debug)]

struct User {
id: i32,
name: String,
email: String,
}

fn main() -> Result<()> {
// … (接続、テーブル作成、INSERT処理、SELECT処理は省略) …
let conn = Connection::open(“my_database.db”)?;
// テーブル作成とデータの存在確認（省略）

println!("\n--- ユーザーデータを削除 ---");

// DELETE 文のプリペアドステートメントを作成 (パラメータ付き)
let mut stmt_delete = conn.prepare("DELETE FROM users WHERE id = ?")?;

// パラメータをバインドしてステートメントを実行
// 影響を受けた行数が返される
let deleted_rows = stmt_delete.execute(params![2])?;

println!("ID=2 のユーザーを削除しました。影響を受けた行数: {}", deleted_rows);

// 削除されたユーザーが存在しないことを確認 (前述のquery_rowのコードを再利用)
println!("\n--- 削除されたユーザーが存在しないことを確認 (ID=2) ---");
let mut stmt_select_one = conn.prepare("SELECT id, name, email FROM users WHERE id = ?")?;
let user_id_2 = stmt_select_one.query_row(params![2], |row| {
    Ok(User { id: row.get(0)?, name: row.get(1)?, email: row.get(2)? })
});
match user_id_2 {
    Ok(user) => println!("{:?}", user), // ここは実行されないはず
    Err(rusqlite::Error::QueryReturnedNoRows) => {
        println!("指定されたIDのユーザーは見つかりませんでした (削除成功確認)。");
    }
    Err(e) => eprintln!("ユーザー取得エラー: {}", e),
}

println!("\n--- 削除されなかったユーザー情報を確認 (ID=1) ---");
let user_id_1 = stmt_select_one.query_row(params![1], |row| {
    Ok(User { id: row.get(0)?, name: row.get(1)?, email: row.get(2)? })
});
 match user_id_1 {
    Ok(user) => println!("{:?}", user),
    Err(e) => eprintln!("ユーザー取得エラー: {}", e),
}

Ok(())

}
“`

解説：

  1. conn.prepare("DELETE FROM users WHERE id = ?")?: DELETE FROM 文を準備します。WHERE id = ? で削除対象の行を特定します。
  2. let deleted_rows = stmt_delete.execute(params![2])?;: プリペアドステートメントを実行します。params![2] で、? に対象のID（2）をバインドしています。
  3. execute メソッドは、この操作によって影響を受けた行数を返します。この例では、ID=2の行が見つかれば deleted_rows は1になります。ID=2の行が存在しなければ、0が返されます。

このコードを実行すると、ID=2のユーザーデータが削除され、その後の確認でそのユーザーが見つからず、ID=1のユーザーはまだ存在することが示されます。

トランザクション

データベース操作において、複数の操作をまとめて不可分な単位として扱いたい場合があります。例えば、「口座Aから1000円引き出し、口座Bに1000円預け入れ」という操作は、引き出しだけが成功して預け入れが失敗すると、データの整合性が崩れてしまいます。このような場合、これらの操作を「トランザクション」として扱い、すべての操作が成功するか、またはすべての操作が失敗して変更が元に戻される（ロールバックされる）ようにします。

SQLiteはACID準拠のトランザクションをサポートしています。rusqlite では、Connection オブジェクトのメソッドを使ってトランザクションを管理できます。

トランザクションを開始するには conn.transaction() メソッドを使用するのが最もRustらしい方法です。これはスコープ付きのトランザクションを提供し、クロージャ内でデータベース操作を実行させます。クロージャが成功裏に完了するとトランザクションは自動的にコミットされ、クロージャ内でエラーが発生したりパニックしたりした場合はトランザクションは自動的にロールバックされます。

ユーザーのメールアドレスを一括で更新するトランザクションの例を見てみましょう。

“`rust
use rusqlite::{Connection, Result, params};

[derive(Debug)]

struct User {
id: i32,
name: String,
email: String,
}

fn main() -> Result<()> {
// … (接続、テーブル作成、INSERT処理は省略) …
let conn = Connection::open(“my_database.db”)?;
// テーブル作成とデータの存在確認（省略）

println!("\n--- トランザクションを開始 ---");

// conn.transaction() メソッドでトランザクションを開始
let transaction_result = conn.transaction(|tx| {
    // クロージャ内部では TxnRef (トランザクション参照) を使う
    // これは Connection と似ているが、トランザクション内での操作に限定される

    println!("トランザクション内で操作を実行...");

    // ID=1のユーザーのメールアドレスを更新
    let updated_rows1 = tx.execute(
        "UPDATE users SET email = ? WHERE id = ?",
        params!["[email protected]", 1],
    )?;
    println!("  ID=1 更新。影響行数: {}", updated_rows1);

    // ID=3のユーザーのメールアドレスを更新
    let updated_rows3 = tx.execute(
        "UPDATE users SET email = ? WHERE id = ?",
        params!["[email protected]", 3],
    )?;
    println!("  ID=3 更新。影響行数: {}", updated_rows3);

    // クロージャが成功裏に終了すると、トランザクションはコミットされる
    println!("トランザクション内操作 成功。");
    Ok(()) // クロージャは Result<(), rusqlite::Error> を返す必要がある
}); // クロージャのスコープが終了

// transaction_result は Result<(), rusqlite::Error>
match transaction_result {
    Ok(()) => println!("トランザクションが正常にコミットされました。"),
    Err(e) => {
        // クロージャ内でエラーが発生した場合、ここで Err(e) となる
        eprintln!("トランザクションがロールバックされました: {}", e);
    }
}

println!("\n--- トランザクション後のユーザー情報を確認 ---");
let mut stmt_select_all = conn.prepare("SELECT id, name, email FROM users")?;
let user_iter = stmt_select_all.query([])?;
for row_result in user_iter {
    let row = row_result?;
    println!("{:?}", User { id: row.get(0)?, name: row.get(1)?, email: row.get(2)? });
}


println!("\n--- ロールバックされるトランザクションの例 ---");

let transaction_result_rollback = conn.transaction(|tx| {
    println!("ロールバックされるトランザクション内で操作を実行...");

    // ID=1のメールアドレスを再度更新
    let updated_rows1 = tx.execute(
        "UPDATE users SET email = ? WHERE id = ?",
        params!["[email protected]", 1],
    )?;
    println!("  ID=1 更新。影響行数: {}", updated_rows1);

    // ここで意図的にエラーを返す
    println!("  意図的にエラーを発生させます...");
    Err(rusqlite::Error::UserFunctionError("カスタムエラー".into())) // Example error

    // クロージャがエラーを返すと、トランザクションはロールバックされる
});

 match transaction_result_rollback {
    Ok(()) => println!("ロールバックされるべきトランザクションが誤ってコミットされました (これは予期しない)。"),
    Err(e) => {
        // クロージャ内でエラーが発生した場合、ここで Err(e) となる
        eprintln!("トランザクションが予期通りロールバックされました: {}", e);
    }
}

println!("\n--- ロールバック後のユーザー情報を確認 ---");
let mut stmt_select_all_after_rollback = conn.prepare("SELECT id, name, email FROM users")?;
let user_iter_after_rollback = stmt_select_all_after_rollback.query([])?;
for row_result in user_iter_after_rollback {
    let row = row_result?;
    println!("{:?}", User { id: row.get(0)?, name: row.get(1)?, email: row.get(2)? });
}


Ok(())

}
“`

解説：

  1. conn.transaction(|tx| { ... }): Connection オブジェクトの transaction メソッドを呼び出します。このメソッドは引数としてクロージャを受け取ります。
  2. クロージャは単一の引数 tx: &TxnRef を受け取ります。TxnRef はトランザクションコンテキスト内でのデータベース接続を表します。execute, prepare などのメソッドは TxnRef 上でも呼び出すことができます。
  3. クロージャ内部では、複数の execute 操作を実行しています。これらの操作はすべて同じトランザクションの一部となります。
  4. クロージャは Result<(), rusqlite::Error> を返す必要があります。
    • クロージャが Ok(()) を返して正常に終了した場合、transaction メソッドはデータベースにトランザクションをコミットするように指示します。コミットが成功すれば transaction メソッド全体は Ok(()) を返します。
    • クロージャが Err(e) を返したり、パニックしたりした場合、transaction メソッドはデータベースにトランザクションをロールバックするように指示します。ロールバックが成功すれば transaction メソッド全体は Err(e) を返します。
  5. transaction メソッド自体の戻り値も Result<(), rusqlite::Error> なので、呼び出し側でこの Result を適切に処理する必要があります。
  6. ロールバックの例では、2つ目のトランザクションクロージャ内で意図的にエラーを返しています。これにより、クロージャ内で実行された UPDATE 操作が取り消され、データベースの状態はトランザクション開始前の状態に戻されます。

このコードを実行すると、最初のトランザクションでID=1とID=3のユーザーのメールアドレスが更新され、2つ目のトランザクション（ID=1のメールアドレスを再度更新しようとするもの）はエラーでロールバックされ、その変更が適用されないことが確認できます。

conn.transaction() を使う方法は、手動で BEGIN, COMMIT, ROLLBACK SQL文を実行するよりも安全です。なぜなら、RustのスコープとResult型によるエラーハンドリングが、コミットまたはロールバックを自動的に保証してくれるからです。

エラーハンドリングの詳細

これまでの例で ? オペレーターを使ってエラーを簡単に伝播させてきましたが、rusqlite のエラーについてもう少し詳しく見てみましょう。rusqlite のほとんどの操作は Result<T, rusqlite::Error> を返します。

rusqlite::Error はenumであり、発生したエラーの種類に関する情報を含んでいます。主要なエラーの種類としては以下のようなものがあります。

  • rusqlite::Error::SqliteFailure(ErrorCode, Option<String>): SQLite Cライブラリからのエラー。ErrorCode はSQLite固有のエラーコード（例: ErrorCode::Constraint (制約違反), ErrorCode::NotFound (ファイル見つからず)）を表し、Option<String> には詳細なエラーメッセージが含まれることが多いです。
  • rusqlite::Error::QueryReturnedNoRows: query_row を呼び出したが、クエリが0行を返した場合。
  • rusqlite::Error::QueryReturnedMultipleRows: query_row を呼び出したが、クエリが複数行を返した場合。
  • rusqlite::Error::InvalidParameterCount(expected, actual): プリペアドステートメントのパラメータ数と、バインドした値の数が一致しない場合。
  • rusqlite::Error::InvalidColumnType(index, name, requested, found): row.get() で指定したRustの型と、SQLiteのカラムの型アフィニティまたは実際の値が互換性がない場合。
  • rusqlite::Error::FromSqlConversionFailure(index, found, requested, cause): FromSql トレイトの実装内で型変換に失敗した場合。
  • rusqlite::Error::IntegralValueTooLarge(index, kind): 整数値を変換しようとしたが、指定されたRustの型に収まらない場合。
  • rusqlite::Error::UserFunctionError(Cow<'static, str>): UDF (User-Defined Function) からのエラー。
  • rusqlite::Error::ExecuteReturnedResults: execute メソッドを呼び出したが、実行したSQL文が結果セットを返した場合（SELECT文などをexecuteで実行しようとした場合）。
  • rusqlite::Error::PrepareReturnedResults: prepare メソッドを呼び出したが、準備したSQL文が結果セットを返した場合。
  • その他、ファイルIOエラーなど。

具体的なエラーの種類に応じて処理を分けたい場合は、match 式を使用します。

“`rust
use rusqlite::{Connection, Result, params, ErrorCode}; // ErrorCode をインポート

// … User struct definition …

fn main() -> Result<()> {
let conn = Connection::open(“my_database.db”)?;
// テーブル作成（UNIQUE制約あり）
conn.execute(
“CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
email TEXT NOT NULL UNIQUE
)”,
[],
)?;
println!(“‘users’ テーブルを作成または確認しました。”);

// ユーザーを挿入 (成功するはず)
let insert_result1 = conn.execute("INSERT INTO users (name, email) VALUES (?, ?)", params!["Dave", "[email protected]"]);
 match insert_result1 {
    Ok(rows) => println!("Dave 挿入成功。影響行数: {}", rows),
    Err(e) => eprintln!("Dave 挿入エラー: {}", e),
}


// UNIQUE 制約違反を起こす挿入
println!("\n--- UNIQUE 制約違反の例 ---");
let insert_result2 = conn.execute("INSERT INTO users (name, email) VALUES (?, ?)", params!["Eva", "[email protected]"]);
match insert_result2 {
    Ok(rows) => println!("Eva 挿入成功。影響行数: {}", rows), // ここは実行されない
    Err(rusqlite::Error::SqliteFailure(ErrorCode::Constraint, Some(msg))) => {
        // SQLiteConstraint: UNIQUE constraint failed: users.email
        eprintln!("挿入エラー: UNIQUE制約違反: {}", msg);
    }
     Err(e) => {
        // その他の rusqlite エラー
        eprintln!("挿入エラー: {}", e);
    }
}

 println!("\n--- 存在しないIDのユーザー取得の例 ---");
 let mut stmt_select_one = conn.prepare("SELECT id, name, email FROM users WHERE id = ?")?;
 let user_id_99 = stmt_select_one.query_row(params![99], |row| {
    Ok(User { id: row.get(0)?, name: row.get(1)?, email: row.get(2)? })
});
match user_id_99 {
    Ok(user) => println!("ユーザーが見つかりました: {:?}", user),
    Err(rusqlite::Error::QueryReturnedNoRows) => {
        println!("エラー処理例: 指定されたIDのユーザーは見つかりませんでした。");
    }
    Err(e) => {
        eprintln!("ユーザー取得エラー: {}", e);
    }
}


Ok(())

}
“`

この例では、同じメールアドレスでの挿入を試みることで ErrorCode::Constraint エラーが発生し、query_row で存在しないIDを指定することで QueryReturnedNoRows エラーが発生する様子を示しています。match 式を使うことで、これらの特定のエラーケースを捕捉し、異なる処理を実行することができます。

Rustの標準ライブラリの Error トレイトを実装しているため、他のエラー型と組み合わせて thiserror や anyhow のようなクレートと一緒に使うことも容易です。

パフォーマンスの考慮

SQLiteは軽量ですが、効率的なデータベース操作を行うためにはいくつか考慮すべき点があります。

  1. プリペアドステートメントの再利用: 前述の通り、同じ構造のSQL文を繰り返し実行する場合は、毎回 prepare を呼び出すのではなく、一度作成した Statement オブジェクトを再利用してください。Statement は execute や query を複数回呼び出すことができます。

  2. トランザクションによる一括処理: 多数のINSERT, UPDATE, DELETE操作を行う場合、個々の操作ごとに自動コミットさせるのではなく、一つのトランザクション内にまとめて実行することでパフォーマンスが大幅に向上します。これは、トランザクションが完了するまでディスクへの書き込み（ジャーナリング）をまとめて行うためです。conn.transaction() メソッドを積極的に活用しましょう。

    “`rust
    // 1000件のデータをトランザクションなしで挿入 (遅い)
    // let mut stmt_insert = conn.prepare(“INSERT INTO users (name, email) VALUES (?, ?)”)?;
    // for i in 0..1000 {
    // stmt_insert.execute(params![&format!(“User{}”, i), &format!(“user{}@example.com”, i)])?;
    // }

    // 1000件のデータをトランザクション内で挿入 (速い)
    println!(“\n— 1000件のデータをトランザクション内で挿入 —“);
    conn.transaction(|tx| {
    let mut stmt_insert = tx.prepare(“INSERT INTO users (name, email) VALUES (?, ?)”)?;
    for i in 0..1000 {
    stmt_insert.execute(params![&format!(“BulkUser{}”, i), &format!(“bulk{}@example.com”, i)])?;
    }
    Ok(())
    })?;
    println!(“1000件のデータ挿入が完了しました。”);
    “`
    このコードは、トランザクションを使用した場合としない場合の性能差を示すための概念的なものです。実際に実行すると、トランザクションを使った方が圧倒的に高速であることが体感できます。

  3. インデックスの利用: WHERE 句や ORDER BY 句で頻繁に使用する列にはインデックスを作成することを検討しましょう。インデックスは検索やソートのパフォーマンスを向上させますが、データの挿入や更新時には追加のオーバーヘッドが発生します。
    sql
    CREATE INDEX idx_users_email ON users (email);
    このSQL文を conn.execute() で実行することで、email 列にインデックスを作成できます。

  4. PRAGMAコマンド: SQLiteにはデータベースの動作を調整するための PRAGMA コマンドが多数用意されています。例えば、journal_mode や synchronous の設定を変更することで、書き込みパフォーマンスやクラッシュからの復旧能力を調整できます。

    • PRAGMA journal_mode = WAL;: Write-Ahead Loggingモードを有効にします。多くのケースで読み書きの並行性と書き込みパフォーマンスが向上します。
    • PRAGMA synchronous = OFF;: ディスクへの書き込み完了を待たなくなるため、書き込みパフォーマンスが向上しますが、OSのクラッシュ時にはデータが失われる可能性があります。通常は NORMAL または FULL を使用します。
      これらのコマンドも conn.execute() で実行できます。
      rust
      conn.execute("PRAGMA journal_mode = WAL;", [])?;
      println!("ジャーナルモードをWALに設定しました。");
      PRAGMA の設定はデータベースのファイルに対して行われるため、一度設定すれば次回以降の接続でも有効です（ただし、一部の設定は接続ごとに必要になる場合もあります）。

これらのパフォーマンスに関する考慮事項は、アプリケーションの要件や使用パターンに応じて適用を検討してください。

より高度なトピック (簡単な紹介)

本記事では rusqlite を使った基本的な操作に焦点を当ててきましたが、Rustでデータベースを扱うためのより高度な方法や関連するクレートも存在します。

  • 非同期データベース操作: rusqlite は同期的なクレートです。Webサーバーのように大量の同時リクエストを処理する場合など、非同期処理が必要な場面では、非同期ランタイム（Tokioやasync-std）と組み合わせて使うか、または非同期に対応したデータベースクレートを検討する必要があります。sqlx クレートはPostgreSQL, MySQL, SQLiteなどを非同期で扱うことができ、SQLクエリをコンパイル時に検証する機能も持っています。
  • ORM (Object-Relational Mapper) / クエリビルダー: 複雑なクエリを構築したり、データベーススキーマをRustの構造体と自動的にマッピングしたりするのに役立つクレートがあります。
    • Diesel: Rustで最も人気のあるORMの一つです。コンパイル時にSQLをチェックする機能や、スキーマ定義からRustのコードを生成する機能など、強力な機能を持っています。ただし、学習コストはやや高めです。
    • SQLx: 前述の非同期対応に加え、SQLクエリをコンパイル時に検証できるのが大きな特徴です。ORMというよりは「型安全なSQLクライアント」という位置付けで、SQLそのものを書くスタイルが好きな方に向いています。
      これらのクレートは rusqlite とは異なるアプローチでデータベースを扱いますが、より複雑なアプリケーション開発においては検討する価値があります。

これらの高度なトピックについては、本記事の範囲を超えるため詳細な解説は省略しますが、興味があればぜひ調べてみてください。

まとめ

本記事では、RustでSQLiteデータベースを扱うための基本的なステップを詳細に解説しました。

  • rusqlite クレートをプロジェクトに追加し、データベースファイルまたはインメモリデータベースへの接続を確立しました。
  • CREATE TABLE 文を使ってテーブルを作成する方法を学びました。
  • プリペアドステートメントを利用して、安全かつ効率的にデータの挿入 (INSERT), 取得 (SELECT), 更新 (UPDATE), 削除 (DELETE) を行う方法を具体的なコード例と共に理解しました。
  • 特に SELECT における query メソッドによる複数行の取得とイテレーション、query_row メソッドによる単一の行の取得について詳しく見ました。
  • 複数のデータベース操作を不可分な単位として扱うためのトランザクションの概念と、conn.transaction() メソッドを使った安全なトランザクション管理の方法を学びました。
  • rusqlite::Error 型を使ったエラーハンドリングの基本と、特定のSQLiteエラーを捕捉する方法を確認しました。
  • プリペアドステートメントの再利用やトランザクションによる一括処理など、基本的なパフォーマンス考慮事項に触れました。

Rustの所有権システムにより、Connection オブジェクトや Statement オブジェクトは不要になった時点で自動的に解放され、リソースリークを防ぐことができます。rusqlite クレートは、Rustの型システムとSQLiteのデータ型をうまく橋渡しし、比較的安全なデータベース操作を可能にしています。

RustとSQLiteの組み合わせは、その組み込みやすさ、パフォーマンス、そして堅牢性から、多くの種類のアプリケーション開発において強力な選択肢となります。本記事で学んだ基礎知識を元に、ぜひご自身のRustアプリケーションにSQLiteを組み込んでみてください。

さらに学習を進める際は、rusqlite クレートの公式ドキュメントを参照したり、より複雑なクエリ（JOIN, GROUP BYなど）や他の高度な機能（ユーザー定義関数、バックアップ、リストアなど）について調べたりすることをお勧めします。また、より抽象化されたデータベース操作が必要な場合は、DieselやSQLxといったORM/クエリビルダーを検討するのも良いでしょう。

これで、RustでSQLiteを扱うための基本的な扉は開かれました。この記事が、皆さんのRustとデータベースを使った開発の一助となれば幸いです。

コメントする

メールアドレスが公開されることはありません。 ※ が付いている欄は必須項目です

上部へスクロール