MENU
  1. ホーム
  2. Rust
  3. Rustでクエリビルダーを活用！Dieselで動的SQLを構築する方法

Rustでクエリビルダーを活用！Dieselで動的SQLを構築する方法

Rust

Rustでデータベース操作を行う際、静的なSQLだけではカバーしきれない場面が多々あります。たとえば、検索条件が動的に変わるシナリオや、ユーザー入力に基づいてクエリを柔軟に変更する必要がある場合です。こうした状況では、動的SQLの構築が不可欠です。

Rustの人気ORMライブラリであるDieselは、クエリビルダーとしての機能を提供し、型安全にSQLを生成することが可能です。特に、DieselのQueryDslを使用することで、条件分岐やフィルタリングを柔軟に実装し、動的SQLを効率よく構築できます。

本記事では、Dieselの概要から、QueryDslを使った動的SQLの構築方法、さらにはパフォーマンスの最適化やエラー処理のポイントまで、詳しく解説します。Rustのデータベース操作をより効果的に行うための知識を深めていきましょう。

目次
  1. Dieselとは何か
    1. Dieselの特徴
    2. DieselがRust開発者に選ばれる理由
  2. クエリビルダーの基本概念
    1. 静的SQLと動的SQLの違い
    2. クエリビルダーのメリット
    3. DieselのQueryDslを使うクエリビルダー
  3. Dieselを導入する方法
    1. 1. Diesel CLIのインストール
    2. 2. Cargo.tomlにDieselを追加
    3. 3. データベース設定ファイルの作成
    4. 4. Dieselの初期化
    5. 5. マイグレーションの作成
    6. Diesel導入後の準備完了
  4. Dieselの基本的な使い方
    1. 1. スキーマの定義
    2. 2. モデルの作成
    3. 3. データの挿入
    4. 4. データの取得
    5. 5. データの更新
    6. 6. データの削除
    7. まとめ
  5. 動的SQLを構築するためのQueryDsl
    1. 1. QueryDslを使った基本的なフィルタリング
    2. 2. 複数条件を組み合わせた動的クエリ
    3. 3. 複数条件によるAND/ORの組み合わせ
    4. 4. 動的にソートを指定する
    5. まとめ
  6. 条件分岐を伴うクエリの作成
    1. 1. オプション引数を使った動的クエリ
    2. 2. AND条件とOR条件を組み合わせる
    3. 3. 複数のフィルタを関数でまとめる
    4. 4. デバッグ情報を出力する
    5. まとめ
  7. パフォーマンスとエラー処理
    1. 1. パフォーマンス向上のテクニック
    2. 2. エラー処理のベストプラクティス
    3. 3. デバッグ時のクエリ確認
    4. まとめ
  8. Dieselクエリの応用例
    1. 1. ページネーションの実装
    2. 2. 動的なソート条件の指定
    3. 3. 複数テーブルの結合 (JOIN)
    4. 4. 複雑な条件での検索
    5. 5. トランザクションを使った一括処理
    6. まとめ
  9. まとめ

Dieselとは何か


Dieselは、Rust言語で使用される強力なORM（Object-Relational Mapper）ライブラリです。データベースとのやり取りを型安全に行うために設計されており、コンパイル時にSQLの誤りを検出することが可能です。

Dieselの特徴

  • 型安全なクエリ：SQL文の構築がコンパイル時に型チェックされるため、ランタイムエラーを大幅に減らせます。
  • クエリビルダー：QueryDslを利用して、柔軟なクエリ構築が可能です。
  • サポートするデータベース：PostgreSQL、MySQL、SQLiteなどの主要なデータベースをサポートしています。
  • マイグレーション機能：データベーススキーマのバージョン管理を効率的に行えます。

DieselがRust開発者に選ばれる理由


Rustの安全性とパフォーマンスを活かしつつ、データベース操作の安全性を確保したい場合、Dieselは非常に有用です。特に、コンパイル時にエラーを検出する仕組みは、運用時のバグを減少させ、コードの品質向上につながります。

Dieselを使うことで、効率的かつ安全にデータベースとやり取りできるため、多くのRust開発者に選ばれています。

クエリビルダーの基本概念


クエリビルダーは、プログラム内でSQLクエリを動的に構築するためのツールです。テキストベースでSQL文を直接書く代わりに、コードを通じてクエリを組み立てるため、可読性と保守性が向上します。Rustにおけるクエリビルダーの代表例がDieselのQueryDslです。

静的SQLと動的SQLの違い

  • 静的SQL：
    あらかじめ決まったSQL文を記述します。構造が固定されているため、シンプルなクエリには向いていますが、柔軟性に欠けます。
  SELECT * FROM users WHERE age > 30;
  • 動的SQL：
    実行時に条件を変更したり、複数の条件を組み合わせたりする柔軟なクエリです。プログラムの要件に応じて、クエリを動的に生成します。
  let min_age = 30;
  users::table.filter(users::age.gt(min_age));

クエリビルダーのメリット

  1. 型安全性：クエリの構文やデータ型がコンパイル時にチェックされ、エラーを早期に発見できます。
  2. 可読性：SQL文を直接書くよりも、コードとして構築するため読みやすくなります。
  3. 柔軟性：検索条件や結合するテーブルを動的に変更しやすくなります。
  4. セキュリティ：SQLインジェクションのリスクを低減できます。

DieselのQueryDslを使うクエリビルダー


Dieselでは、QueryDslを使って型安全にクエリを構築します。以下は簡単な使用例です：

use diesel::prelude::*;
use crate::schema::users::dsl::*;

let results = users
    .filter(age.gt(30))
    .limit(5)
    .load::<User>(&connection)
    .expect("Error loading users");

このように、Dieselのクエリビルダーは、Rustの特徴を活かして安全かつ柔軟にSQLを構築できる手段を提供します。

Dieselを導入する方法

RustプロジェクトでDieselを使うには、いくつかの手順を踏んで設定を行います。以下に、Dieselのインストールから初期設定までの流れを解説します。

1. Diesel CLIのインストール


Dieselを使うには、コマンドラインツール（CLI）が必要です。以下のコマンドでインストールします。

cargo install diesel_cli --no-default-features --features "postgres"

ここでは、PostgreSQL用にDiesel CLIをインストールしています。データベースがMySQLの場合は"mysql"、SQLiteの場合は"sqlite"に変更してください。

2. Cargo.tomlにDieselを追加


プロジェクトのCargo.tomlにDieselとデータベース用のクレートを追加します。例としてPostgreSQLの場合：

[dependencies]
diesel = { version = "1.4.8", features = ["postgres"] }
dotenv = "0.15"  # 環境変数管理のため

SQLiteやMySQLを使う場合は、featuresの値を変更します。

3. データベース設定ファイルの作成


プロジェクトのルートディレクトリに.envファイルを作成し、データベース接続情報を記述します。

DATABASE_URL=postgres://username:password@localhost/database_name

SQLiteの場合はファイルパス、MySQLの場合はMySQL接続文字列を指定します。

4. Dieselの初期化


Dieselの設定ファイルとフォルダ構造を初期化するには、以下のコマンドを実行します。

diesel setup

このコマンドにより、migrationsフォルダとdiesel.tomlが作成され、データベースに必要な初期設定が行われます。

5. マイグレーションの作成


新しいテーブルを追加するには、マイグレーションを作成します。

diesel migration generate create_users

これにより、migrationsフォルダ内にアップ用とダウン用のSQLファイルが生成されます。これらのファイルにSQL文を記述し、以下のコマンドで適用します。

diesel migration run

Diesel導入後の準備完了


これでDieselの導入は完了です。以降、Dieselを使ってRustからデータベース操作を行う準備が整いました。

Dieselの基本的な使い方

Dieselを導入したら、基本的なデータベース操作を試してみましょう。ここでは、データの挿入、クエリ、更新、削除の基本操作を解説します。

1. スキーマの定義


Dieselでは、テーブルのスキーマ定義をschema.rsファイルで管理します。マイグレーションを実行すると、以下のようなスキーマが生成されます。

table! {
    users (id) {
        id -> Int4,
        name -> Varchar,
        age -> Int4,
    }
}

2. モデルの作成


Rust構造体でテーブルに対応するモデルを定義します。

#[derive(Queryable)]
struct User {
    id: i32,
    name: String,
    age: i32,
}

3. データの挿入


データを挿入するには、Insertableトレイトを実装した構造体を作成します。

use diesel::prelude::*;
use crate::schema::users;

#[derive(Insertable)]
#[table_name = "users"]
struct NewUser<'a> {
    name: &'a str,
    age: i32,
}

fn create_user(conn: &PgConnection, name: &str, age: i32) {
    let new_user = NewUser { name, age };

    diesel::insert_into(users::table)
        .values(&new_user)
        .execute(conn)
        .expect("Error inserting new user");
}

4. データの取得


データをクエリして取得する方法です。

fn get_users(conn: &PgConnection) {
    use crate::schema::users::dsl::*;

    let results = users
        .limit(5)
        .load::<User>(conn)
        .expect("Error loading users");

    for user in results {
        println!("ID: {}, Name: {}, Age: {}", user.id, user.name, user.age);
    }
}

5. データの更新


特定のレコードを更新する例です。

fn update_user_age(conn: &PgConnection, user_id: i32, new_age: i32) {
    use crate::schema::users::dsl::*;

    diesel::update(users.filter(id.eq(user_id)))
        .set(age.eq(new_age))
        .execute(conn)
        .expect("Error updating user");
}

6. データの削除


レコードを削除する方法です。

fn delete_user(conn: &PgConnection, user_id: i32) {
    use crate::schema::users::dsl::*;

    diesel::delete(users.filter(id.eq(user_id)))
        .execute(conn)
        .expect("Error deleting user");
}

まとめ


これらの基本操作を通じて、Dieselを使ったデータベース操作の流れを理解できます。Dieselは型安全性が高く、Rustの強力な機能を活用してデータ操作を安全かつ効率的に行えます。

動的SQLを構築するためのQueryDsl

DieselのQueryDslは、Rustで型安全に動的SQLクエリを構築するための強力なツールです。これを使えば、条件に応じてクエリを柔軟に変更することができます。ここでは、QueryDslを使った動的SQLの構築方法について解説します。

1. QueryDslを使った基本的なフィルタリング


まずは、シンプルな条件でデータをフィルタリングする例です。

use diesel::prelude::*;
use crate::schema::users::dsl::*;

fn get_users_by_age(conn: &PgConnection, min_age: i32) -> Vec<User> {
    users
        .filter(age.gt(min_age))
        .load::<User>(conn)
        .expect("Error loading users")
}

このコードでは、min_ageの値に応じてage > min_ageの条件が動的に変更されます。

2. 複数条件を組み合わせた動的クエリ


複数の条件を組み合わせて動的にクエリを構築する例です。

fn get_users_by_filters(conn: &PgConnection, min_age: Option<i32>, name_filter: Option<&str>) -> Vec<User> {
    let mut query = users.into_boxed();

    if let Some(age) = min_age {
        query = query.filter(age.gt(age));
    }

    if let Some(name) = name_filter {
        query = query.filter(name.like(format!("%{}%", name)));
    }

    query.load::<User>(conn).expect("Error loading users")
}
  • into_boxed()：動的クエリを構築する際に使用し、条件を後から追加するための準備をします。
  • 条件の追加：if let Some()を使って、渡されたオプションに応じてフィルタを追加します。

3. 複数条件によるAND/ORの組み合わせ


ANDやORを使って複雑なクエリを構築する例です。

use diesel::dsl::or;

fn get_users_by_complex_filters(conn: &PgConnection, min_age: i32, max_age: i32, name_filter: &str) -> Vec<User> {
    users
        .filter(age.between(min_age, max_age).or(name.like(format!("%{}%", name_filter))))
        .load::<User>(conn)
        .expect("Error loading users")
}

この例では、年齢が指定した範囲内であるか、または名前に特定の文字列が含まれているかでフィルタしています。

4. 動的にソートを指定する


クエリ結果を動的にソートする方法です。

fn get_users_sorted(conn: &PgConnection, sort_by_age: bool) -> Vec<User> {
    let mut query = users.into_boxed();

    if sort_by_age {
        query = query.order(age.asc());
    } else {
        query = query.order(name.asc());
    }

    query.load::<User>(conn).expect("Error loading users")
}

まとめ


DieselのQueryDslを使うことで、動的SQLクエリを柔軟かつ安全に構築できます。条件分岐や複雑なフィルタリング、動的ソートを活用すれば、Rustアプリケーションのデータベース操作を効率的に行えるでしょう。

条件分岐を伴うクエリの作成

動的SQLを構築する際、条件分岐を伴うクエリが必要になることがあります。DieselのQueryDslを使うことで、複数の検索条件を柔軟に組み合わせることが可能です。ここでは、いくつかの条件分岐を用いたクエリ作成方法を解説します。

1. オプション引数を使った動的クエリ


RustのOption型を活用して、条件が指定された場合のみクエリにフィルタを追加する方法です。

use diesel::prelude::*;
use crate::schema::users::dsl::*;

fn get_users_with_filters(conn: &PgConnection, min_age: Option<i32>, max_age: Option<i32>, name_filter: Option<&str>) -> Vec<User> {
    let mut query = users.into_boxed();

    if let Some(min) = min_age {
        query = query.filter(age.ge(min));
    }

    if let Some(max) = max_age {
        query = query.filter(age.le(max));
    }

    if let Some(name) = name_filter {
        query = query.filter(name.like(format!("%{}%", name)));
    }

    query.load::<User>(conn).expect("Error loading users")
}

ポイント：

  • into_boxed()：動的に条件を追加するための準備を行います。
  • if let Some()：値が存在する場合のみ、フィルタを追加します。

2. AND条件とOR条件を組み合わせる


複数の条件をANDやORで組み合わせるクエリを作成する例です。

use diesel::dsl::or;

fn get_users_by_and_or_conditions(conn: &PgConnection, min_age: Option<i32>, name_filter: Option<&str>) -> Vec<User> {
    let mut query = users.into_boxed();

    if let Some(min) = min_age {
        query = query.filter(age.ge(min));
    }

    if let Some(name) = name_filter {
        query = query.filter(or(name.like(format!("%{}%", name)), age.lt(18)));
    }

    query.load::<User>(conn).expect("Error loading users")
}

解説：

  • or()を使うことで、名前に特定の文字列が含まれているか、年齢が18未満のいずれかに一致する場合にデータを取得します。

3. 複数のフィルタを関数でまとめる


条件分岐が多くなる場合、フィルタを関数化してクエリをシンプルに保つことができます。

fn apply_age_filter(query: users::BoxedQuery<'_, diesel::pg::Pg>, min_age: Option<i32>, max_age: Option<i32>) -> users::BoxedQuery<'_, diesel::pg::Pg> {
    let mut filtered_query = query;

    if let Some(min) = min_age {
        filtered_query = filtered_query.filter(age.ge(min));
    }

    if let Some(max) = max_age {
        filtered_query = filtered_query.filter(age.le(max));
    }

    filtered_query
}

fn get_filtered_users(conn: &PgConnection, min_age: Option<i32>, max_age: Option<i32>) -> Vec<User> {
    let query = users.into_boxed();
    let filtered_query = apply_age_filter(query, min_age, max_age);

    filtered_query.load::<User>(conn).expect("Error loading users")
}

メリット：

  • コードがモジュール化され、読みやすくなります。
  • フィルタロジックを再利用しやすくなります。

4. デバッグ情報を出力する


クエリをデバッグするには、debug_queryマクロを使ってSQLを表示できます。

use diesel::debug_query;

fn debug_users_query(conn: &PgConnection) {
    let query = users.filter(age.gt(30));
    println!("{:?}", debug_query::<diesel::pg::Pg, _>(&query));
}

出力例：

SELECT * FROM users WHERE age > $1

まとめ


条件分岐を伴うクエリを作成することで、柔軟にデータベース検索が行えます。Option型や関数化を活用することで、クエリの構造をシンプルかつ可読性の高いものに保つことができます。DieselのQueryDslを使いこなして、Rustで効率的なデータベース操作を実現しましょう。

パフォーマンスとエラー処理

Dieselを使って動的SQLを構築する際には、クエリのパフォーマンス最適化とエラー処理が重要です。これらのポイントを押さえることで、アプリケーションの安定性と効率性が向上します。ここでは、Dieselでのパフォーマンス向上のテクニックとエラー処理のベストプラクティスについて解説します。

1. パフォーマンス向上のテクニック

クエリの最適化


不要なデータを取得しないために、必要なカラムのみを指定してクエリを発行します。

use diesel::prelude::*;
use crate::schema::users::dsl::*;

fn get_user_names(conn: &PgConnection) -> Vec<String> {
    users.select(name).load::<String>(conn).expect("Error loading user names")
}

インデックスの活用


データベーステーブルにインデックスを設定することで、検索速度を向上させます。たとえば、usersテーブルのageカラムにインデックスを追加するSQL：

CREATE INDEX idx_users_age ON users (age);

バッチ処理による効率化


大量のデータを挿入または更新する場合、1件ずつ処理するのではなく、バッチ処理を行うことで効率が向上します。

fn insert_multiple_users(conn: &PgConnection, new_users: Vec<NewUser>) {
    diesel::insert_into(users::table)
        .values(&new_users)
        .execute(conn)
        .expect("Error inserting users");
}

2. エラー処理のベストプラクティス

Result型を使ったエラー処理


DieselのクエリはResult型を返すため、エラー処理を適切に行うことでクラッシュを防げます。

fn get_user_by_id(conn: &PgConnection, user_id: i32) -> Result<User, diesel::result::Error> {
    use crate::schema::users::dsl::*;

    users.find(user_id).first::<User>(conn)
}

呼び出し側でエラーをハンドリングします。

match get_user_by_id(&conn, 1) {
    Ok(user) => println!("User found: {:?}", user),
    Err(e) => eprintln!("Error fetching user: {}", e),
}

クエリ実行時のエラーメッセージをカスタマイズ


エラー発生時に意味のあるメッセージを提供することで、デバッグが容易になります。

fn get_all_users(conn: &PgConnection) -> Vec<User> {
    users.load::<User>(conn).unwrap_or_else(|err| {
        eprintln!("Failed to load users: {}", err);
        vec![]
    })
}

トランザクションを使用する


複数のクエリを安全に実行するためにトランザクションを利用します。エラーが発生した場合、すべての操作をロールバックします。

use diesel::result::Error;

fn create_user_and_log(conn: &PgConnection, new_user: NewUser) -> Result<(), Error> {
    conn.transaction(|| {
        diesel::insert_into(users::table)
            .values(&new_user)
            .execute(conn)?;

        diesel::insert_into(logs::table)
            .values(&NewLog { action: "User Created" })
            .execute(conn)?;

        Ok(())
    })
}

3. デバッグ時のクエリ確認


debug_queryを使って、生成されるSQLクエリを確認できます。

use diesel::debug_query;

fn debug_user_query(conn: &PgConnection) {
    let query = users.filter(age.gt(30));
    println!("{:?}", debug_query::<diesel::pg::Pg, _>(&query));
}

まとめ


パフォーマンス向上には、効率的なクエリ設計やインデックスの活用、バッチ処理が有効です。エラー処理では、Result型を適切に使い、トランザクションで安全性を確保しましょう。Dieselの機能を活用して、信頼性と効率性の高いRustアプリケーションを開発しましょう。

Dieselクエリの応用例

Dieselを使って動的SQLを構築するスキルを身につけたら、さらに高度なクエリを実装してみましょう。ここでは、実際のRustプロジェクトで役立つ応用例をいくつか紹介します。

1. ページネーションの実装

大量のデータを効率的に取得するために、ページネーションを導入する例です。

use diesel::prelude::*;
use crate::schema::users::dsl::*;

fn get_paginated_users(conn: &PgConnection, page: i64, page_size: i64) -> Vec<User> {
    let offset = (page - 1) * page_size;

    users
        .limit(page_size)
        .offset(offset)
        .load::<User>(conn)
        .expect("Error loading paginated users")
}

使用例：

let users_page = get_paginated_users(&conn, 2, 10); // 2ページ目、1ページ10件

2. 動的なソート条件の指定

ソート条件を動的に切り替える例です。

fn get_users_sorted_by(conn: &PgConnection, sort_by: &str) -> Vec<User> {
    let mut query = users.into_boxed();

    match sort_by {
        "age_asc" => query = query.order(age.asc()),
        "age_desc" => query = query.order(age.desc()),
        "name_asc" => query = query.order(name.asc()),
        "name_desc" => query = query.order(name.desc()),
        _ => query = query.order(id.asc()), // デフォルトのソート
    }

    query.load::<User>(conn).expect("Error loading sorted users")
}

使用例：

let sorted_users = get_users_sorted_by(&conn, "age_desc");

3. 複数テーブルの結合 (JOIN)

関連するデータを複数のテーブルから取得するための結合クエリです。

use crate::schema::{users, posts};
use diesel::prelude::*;

#[derive(Queryable, Debug)]
struct UserWithPost {
    user_id: i32,
    user_name: String,
    post_title: String,
}

fn get_users_with_posts(conn: &PgConnection) -> Vec<UserWithPost> {
    users::table
        .inner_join(posts::table)
        .select((users::id, users::name, posts::title))
        .load::<UserWithPost>(conn)
        .expect("Error loading users with posts")
}

解説：

  • inner_join：usersテーブルとpostsテーブルを内部結合します。
  • select：必要なカラムのみを取得します。

4. 複雑な条件での検索

複数の条件を組み合わせたクエリの例です。

fn get_active_users_in_age_range(conn: &PgConnection, min_age: i32, max_age: i32) -> Vec<User> {
    use crate::schema::users::dsl::*;

    users
        .filter(age.between(min_age, max_age))
        .filter(active.eq(true))
        .load::<User>(conn)
        .expect("Error loading active users in age range")
}

使用例：

let active_users = get_active_users_in_age_range(&conn, 20, 40);

5. トランザクションを使った一括処理

複数のデータ操作をトランザクション内で安全に実行する例です。

fn create_user_with_post(conn: &PgConnection, new_user: NewUser, new_post: NewPost) -> Result<(), diesel::result::Error> {
    conn.transaction(|| {
        diesel::insert_into(users::table)
            .values(&new_user)
            .execute(conn)?;

        diesel::insert_into(posts::table)
            .values(&new_post)
            .execute(conn)?;

        Ok(())
    })
}

解説：

  • conn.transaction(|| { ... })：トランザクション内で一連の操作を実行し、エラーが発生した場合は自動でロールバックします。

まとめ

これらの応用例を活用することで、Dieselを使ったRustプロジェクトで高度なデータ操作が可能になります。ページネーション、動的なソート、テーブルの結合、複雑な検索条件、トランザクション処理など、実際の開発に役立つテクニックを習得し、効率的なデータベース操作を実現しましょう。

まとめ

本記事では、RustのORMライブラリDieselを使用して、動的SQLを構築する方法について解説しました。DieselのQueryDslを活用することで、型安全かつ柔軟にクエリを構築できるため、エラーを早期に発見し、効率的なデータベース操作が可能になります。

以下のポイントを振り返りましょう：

  • Dieselの概要と導入方法
  • クエリビルダーの基本概念と動的SQLの構築
  • 条件分岐を伴うクエリや複数条件の組み合わせ
  • パフォーマンス向上のテクニックとエラー処理のベストプラクティス
  • 応用例としてページネーション、JOIN、トランザクション処理

Dieselを使いこなせば、Rustプロジェクトでデータベースと安全にやり取りでき、柔軟なクエリ構築が可能になります。今後の開発にぜひ活かしてみてください。

Rust
SQL クエリビルダー Rust Diesel QueryDsl

コメント

コメントする

目次
  1. Dieselとは何か
    1. Dieselの特徴
    2. DieselがRust開発者に選ばれる理由
  2. クエリビルダーの基本概念
    1. 静的SQLと動的SQLの違い
    2. クエリビルダーのメリット
    3. DieselのQueryDslを使うクエリビルダー
  3. Dieselを導入する方法
    1. 1. Diesel CLIのインストール
    2. 2. Cargo.tomlにDieselを追加
    3. 3. データベース設定ファイルの作成
    4. 4. Dieselの初期化
    5. 5. マイグレーションの作成
    6. Diesel導入後の準備完了
  4. Dieselの基本的な使い方
    1. 1. スキーマの定義
    2. 2. モデルの作成
    3. 3. データの挿入
    4. 4. データの取得
    5. 5. データの更新
    6. 6. データの削除
    7. まとめ
  5. 動的SQLを構築するためのQueryDsl
    1. 1. QueryDslを使った基本的なフィルタリング
    2. 2. 複数条件を組み合わせた動的クエリ
    3. 3. 複数条件によるAND/ORの組み合わせ
    4. 4. 動的にソートを指定する
    5. まとめ
  6. 条件分岐を伴うクエリの作成
    1. 1. オプション引数を使った動的クエリ
    2. 2. AND条件とOR条件を組み合わせる
    3. 3. 複数のフィルタを関数でまとめる
    4. 4. デバッグ情報を出力する
    5. まとめ
  7. パフォーマンスとエラー処理
    1. 1. パフォーマンス向上のテクニック
    2. 2. エラー処理のベストプラクティス
    3. 3. デバッグ時のクエリ確認
    4. まとめ
  8. Dieselクエリの応用例
    1. 1. ページネーションの実装
    2. 2. 動的なソート条件の指定
    3. 3. 複数テーブルの結合 (JOIN)
    4. 4. 複雑な条件での検索
    5. 5. トランザクションを使った一括処理
    6. まとめ
  9. まとめ