MENU
  1. ホーム
  2. Rust
  3. RustでPostgreSQLに接続しクエリを実装する方法を徹底解説

RustでPostgreSQLに接続しクエリを実装する方法を徹底解説

Rust

Rustは、パフォーマンスと安全性を両立するシステムプログラミング言語として注目されており、Webアプリケーションやバックエンド開発でも活用されています。一方、PostgreSQLは信頼性が高く、高機能なリレーショナルデータベース管理システムです。この二つを組み合わせることで、高速で安全性の高いデータベース駆動型アプリケーションを構築できます。

本記事では、RustでPostgreSQLデータベースに接続し、クエリを実装する方法を徹底的に解説します。主に人気のあるクレートであるDieselとSQLxを用いた接続と操作方法を紹介し、それぞれの特徴や使い方、エラー処理のポイントについても詳しく説明します。Rustでデータベース操作を行いたい方にとって、理解と実践の助けになる内容となっています。

目次
  1. RustとPostgreSQLの基本概要
    1. Rustとは何か
    2. PostgreSQLとは何か
    3. RustとPostgreSQLの組み合わせ
  2. RustでPostgreSQLを使うメリット
    1. 高い安全性
    2. 高パフォーマンス
    3. 非同期処理のサポート
    4. 強力な型システム
    5. 豊富なライブラリとエコシステム
    6. 信頼性の高い開発
  3. Dieselクレートを用いた接続方法
    1. 1. Dieselクレートのインストール
    2. 2. Diesel CLIのインストール
    3. 3. データベース設定ファイルの作成
    4. 4. Dieselの初期化
    5. 5. スキーマの定義とマイグレーション
    6. 6. コードでデータベースに接続
    7. 接続確認
  4. Dieselでクエリを実行する方法
    1. 1. テーブルのモデルとスキーマ定義
    2. 2. データの挿入（Create）
    3. 3. データの取得（Read）
    4. 4. データの更新（Update）
    5. 5. データの削除（Delete）
    6. 6. 使用例
    7. まとめ
  5. SQLxクレートを用いた接続方法
    1. 1. SQLxクレートのインストール
    2. 2. データベース設定ファイルの作成
    3. 3. データベースへの接続
    4. 4. 接続プールの解説
    5. 5. 接続確認
    6. 6. コードの補足
  6. SQLxでクエリを実行する方法
    1. 1. 必要なインポートと接続プール
    2. 2. データの挿入（Create）
    3. 3. データの取得（Read）
    4. 4. データの更新（Update）
    5. 5. データの削除（Delete）
    6. 6. クエリ関数の呼び出し
    7. まとめ
  7. DieselとSQLxの比較
    1. 1. Dieselの特徴
    2. 2. SQLxの特徴
    3. 3. DieselとSQLxの比較表
    4. 4. 使い分けのポイント
    5. まとめ
  8. エラー処理とトラブルシューティング
    1. 1. データベース接続エラー
    2. 2. マイグレーションエラー（Diesel）
    3. 3. クエリ実行エラー（Diesel・SQLx）
    4. 4. 非同期エラー（SQLx）
    5. 5. 型不一致エラー
    6. 6. デバッグ時のTips
    7. まとめ
  9. まとめ

RustとPostgreSQLの基本概要


RustとPostgreSQLを効果的に活用するためには、それぞれの基本を理解することが重要です。

Rustとは何か


RustはMozillaが開発したシステムプログラミング言語で、以下の特徴を持ちます：

  • 安全性：メモリ安全性が保証されており、バッファオーバーフローやデータ競合が起こりにくい。
  • 高パフォーマンス：CやC++並みの高速な実行速度を実現する。
  • 並行処理：強力なコンパイル時チェックにより、安全に並行処理を実装可能。

PostgreSQLとは何か


PostgreSQLはオープンソースのリレーショナルデータベース管理システム（RDBMS）で、以下の特徴を持ちます：

  • ACIDトランザクション：データ整合性を保証するトランザクション処理。
  • 拡張性：カスタムデータ型や関数、拡張モジュールをサポート。
  • SQL標準準拠：高度なSQL機能とクエリ最適化が可能。

RustとPostgreSQLの組み合わせ


RustとPostgreSQLを組み合わせることで、安全かつ高性能なデータベースアプリケーションを構築できます。特に以下のシナリオで効果を発揮します：

  • Webバックエンド：高トラフィックでも安定した動作が求められるサービス。
  • データ処理ツール：大量データを高速に処理するシステム。
  • 分散システム：安全性と並行処理が求められるアーキテクチャ。

この後、DieselやSQLxを使った具体的な接続方法やクエリ実装について解説します。

RustでPostgreSQLを使うメリット


RustとPostgreSQLを組み合わせることで得られる利点は、システム開発の効率と品質を向上させます。以下にその主なメリットを解説します。

高い安全性


Rustはメモリ安全性とデータ競合防止をコンパイル時に保証します。これにより、データベース接続やクエリ実行中に発生しがちなランタイムエラーやクラッシュを未然に防ぐことができます。特に、長期間運用するバックエンドサービスに適しています。

高パフォーマンス


RustはC/C++に匹敵する高速な処理性能を持ち、PostgreSQLと連携することで、大量データの読み書きや複雑なクエリを効率的に実行できます。パフォーマンス重視のWebアプリケーションやリアルタイム処理に最適です。

非同期処理のサポート


Rustはasync/await構文をサポートしており、SQLxのような非同期対応クレートを使用することで、非同期でデータベース操作が可能です。これにより、I/O待ち時間を最小限に抑え、スループットを向上させることができます。

強力な型システム


Rustの型システムはクエリ結果の型安全性を保証します。DieselやSQLxを使用すると、SQLの結果がRustの型と一致しない場合、コンパイルエラーが発生し、実行前にバグを発見できます。

豊富なライブラリとエコシステム


Rustには、データベース操作を効率化するクレート（ライブラリ）が豊富に揃っています。代表的なものに以下があります：

  • Diesel：型安全なORM（Object-Relational Mapping）クレート。
  • SQLx：非同期対応のクエリビルダ兼実行ライブラリ。

信頼性の高い開発


Rustの厳格なコンパイル時チェックにより、バグの少ない堅牢なコードを作成できます。データベース操作においても、エラー処理やトランザクション管理がしやすく、信頼性の高いシステムを構築可能です。

これらの利点により、RustとPostgreSQLの組み合わせは、安全性、パフォーマンス、拡張性を重視する開発者にとって理想的な選択肢となります。

Dieselクレートを用いた接続方法


DieselはRustの強力なORM（Object-Relational Mapping）で、型安全なデータベース操作を可能にします。ここでは、Dieselを使ってPostgreSQLに接続する手順を解説します。

1. Dieselクレートのインストール


まず、Cargo.tomlにDieselとPostgreSQL用のクレートを追加します。

[dependencies]
diesel = { version = "1.4.8", features = ["postgres"] }
dotenv = "0.15"

2. Diesel CLIのインストール


Diesel CLIをインストールすることで、データベースのセットアップやマイグレーションが簡単になります。

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

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


.envファイルにデータベース接続情報を記述します。

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

4. Dieselの初期化


以下のコマンドでDieselを初期化します。

diesel setup

これにより、マイグレーション用のディレクトリと設定ファイルが生成されます。

5. スキーマの定義とマイグレーション


マイグレーションファイルを作成して、テーブルを定義します。

diesel migration generate create_users

作成されたup.sqlファイルにSQLクエリを書きます。

CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name VARCHAR NOT NULL,
    email VARCHAR NOT NULL
);

その後、以下のコマンドでマイグレーションを適用します。

diesel migration run

6. コードでデータベースに接続


Rustのコードでデータベースに接続します。

#[macro_use]
extern crate diesel;
extern crate dotenv;

use diesel::prelude::*;
use dotenv::dotenv;
use std::env;

pub fn establish_connection() -> PgConnection {
    dotenv().ok();
    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    PgConnection::establish(&database_url).expect("Error connecting to the database")
}

接続確認


main関数で接続を確認します。

fn main() {
    let connection = establish_connection();
    println!("Database connection established successfully!");
}

これで、Dieselを使ってPostgreSQLへの接続が完了です。次のステップでは、クエリの実行方法について解説します。

Dieselでクエリを実行する方法


Dieselを使用してPostgreSQLにクエリを実行することで、安全かつ効率的にデータ操作が可能です。ここでは、基本的なCRUD（Create, Read, Update, Delete）操作を実装する方法を解説します。

1. テーブルのモデルとスキーマ定義


Dieselでクエリを実行するには、モデルとスキーマを定義します。

schema.rs（Diesel CLIで生成されるファイル）：

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

models.rs（モデルの定義）：

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

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

2. データの挿入（Create）


新しいユーザーをデータベースに挿入します。

use diesel::prelude::*;
use self::models::{NewUser, User};
use self::schema::users::dsl::*;

pub fn create_user<'a>(conn: &PgConnection, user_name: &'a str, user_email: &'a str) -> User {
    let new_user = NewUser {
        name: user_name,
        email: user_email,
    };

    diesel::insert_into(users)
        .values(&new_user)
        .get_result(conn)
        .expect("Error saving new user")
}

3. データの取得（Read）


データベースからすべてのユーザーを取得します。

pub fn get_all_users(conn: &PgConnection) -> Vec<User> {
    users.load::<User>(conn).expect("Error loading users")
}

4. データの更新（Update）


特定のユーザーのメールアドレスを更新します。

pub fn update_user_email(conn: &PgConnection, user_id: i32, new_email: &str) {
    diesel::update(users.find(user_id))
        .set(email.eq(new_email))
        .execute(conn)
        .expect("Error updating user email");
}

5. データの削除（Delete）


特定のユーザーを削除します。

pub fn delete_user(conn: &PgConnection, user_id: i32) {
    diesel::delete(users.find(user_id))
        .execute(conn)
        .expect("Error deleting user");
}

6. 使用例


main関数でCRUD操作を実行します。

fn main() {
    let connection = establish_connection();

    // ユーザーの作成
    let new_user = create_user(&connection, "Alice", "alice@example.com");
    println!("New user created: {} - {}", new_user.id, new_user.name);

    // ユーザーの取得
    let all_users = get_all_users(&connection);
    for user in all_users {
        println!("User: {} - {} - {}", user.id, user.name, user.email);
    }

    // ユーザーの更新
    update_user_email(&connection, new_user.id, "newalice@example.com");
    println!("User email updated.");

    // ユーザーの削除
    delete_user(&connection, new_user.id);
    println!("User deleted.");
}

まとめ


Dieselを使用することで、型安全で効率的にデータベースのCRUD操作が実現できます。Dieselの強力な型システムにより、コンパイル時にエラーを検出でき、バグの少ないコードを作成できます。

SQLxクレートを用いた接続方法


SQLxはRustの非同期対応のデータベースクレートで、SQLクエリをコンパイル時に検証できる特徴があります。ここでは、SQLxを用いてPostgreSQLに接続する手順を解説します。

1. SQLxクレートのインストール


Cargo.tomlにSQLxとPostgreSQL用のクレートを追加します。非同期機能を使うため、runtimeの指定も行います。

[dependencies]
sqlx = { version = "0.6", features = ["postgres", "runtime-tokio", "macros", "chrono"] }
tokio = { version = "1", features = ["full"] }
dotenv = "0.15"

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


.envファイルにPostgreSQL接続情報を記述します。

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

3. データベースへの接続


SQLxを使ってPostgreSQLに接続する非同期関数を作成します。

use sqlx::postgres::PgPoolOptions;
use dotenv::dotenv;
use std::env;

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    dotenv().ok();

    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");

    let pool = PgPoolOptions::new()
        .max_connections(5)
        .connect(&database_url)
        .await?;

    println!("Database connection established successfully!");
    Ok(())
}

4. 接続プールの解説

  • PgPoolOptions：接続プールの設定を行います。
  • max_connections(5)：最大5つの同時接続を許可します。
  • connect(&database_url)：データベースに非同期で接続します。

5. 接続確認


上記のコードを実行して、接続が成功すれば以下のメッセージが表示されます。

Database connection established successfully!

6. コードの補足

  • 非同期実行：SQLxはasync/awaitをサポートしているため、I/O待ち時間を効率的に処理できます。
  • エラーハンドリング：接続エラーが発生した場合、sqlx::Errorとして処理されます。

これで、SQLxを用いたPostgreSQLへの接続準備が整いました。次のステップでは、SQLxを用いたクエリの実行方法について解説します。

SQLxでクエリを実行する方法


SQLxを使えば、非同期で安全にPostgreSQLデータベースに対するクエリを実行できます。ここでは、SQLxを用いたCRUD（Create, Read, Update, Delete）操作の実装方法を解説します。

1. 必要なインポートと接続プール


まず、必要なクレートをインポートし、データベース接続プールを作成します。

use sqlx::{postgres::PgPoolOptions, FromRow};
use dotenv::dotenv;
use std::env;

#[derive(FromRow, Debug)]
struct User {
    id: i32,
    name: String,
    email: String,
}

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    dotenv().ok();
    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");

    let pool = PgPoolOptions::new()
        .max_connections(5)
        .connect(&database_url)
        .await?;

    println!("Database connection established successfully!");

    // ここで各クエリ関数を呼び出します
    Ok(())
}

2. データの挿入（Create）


新しいユーザーをデータベースに挿入します。

async fn create_user(pool: &sqlx::PgPool, name: &str, email: &str) -> Result<(), sqlx::Error> {
    sqlx::query!(
        "INSERT INTO users (name, email) VALUES ($1, $2)",
        name,
        email
    )
    .execute(pool)
    .await?;

    println!("New user created: {} - {}", name, email);
    Ok(())
}

3. データの取得（Read）


すべてのユーザーを取得します。

async fn get_all_users(pool: &sqlx::PgPool) -> Result<(), sqlx::Error> {
    let users = sqlx::query_as!(User, "SELECT id, name, email FROM users")
        .fetch_all(pool)
        .await?;

    for user in users {
        println!("User: {} - {} - {}", user.id, user.name, user.email);
    }
    Ok(())
}

4. データの更新（Update）


特定のユーザーのメールアドレスを更新します。

async fn update_user_email(pool: &sqlx::PgPool, user_id: i32, new_email: &str) -> Result<(), sqlx::Error> {
    sqlx::query!(
        "UPDATE users SET email = $1 WHERE id = $2",
        new_email,
        user_id
    )
    .execute(pool)
    .await?;

    println!("User with ID {} updated with new email: {}", user_id, new_email);
    Ok(())
}

5. データの削除（Delete）


特定のユーザーを削除します。

async fn delete_user(pool: &sqlx::PgPool, user_id: i32) -> Result<(), sqlx::Error> {
    sqlx::query!(
        "DELETE FROM users WHERE id = $1",
        user_id
    )
    .execute(pool)
    .await?;

    println!("User with ID {} deleted.", user_id);
    Ok(())
}

6. クエリ関数の呼び出し


main関数内でCRUD操作を実行します。

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    dotenv().ok();
    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");

    let pool = PgPoolOptions::new()
        .max_connections(5)
        .connect(&database_url)
        .await?;

    println!("Database connection established successfully!");

    // データの挿入
    create_user(&pool, "Alice", "alice@example.com").await?;

    // データの取得
    get_all_users(&pool).await?;

    // データの更新
    update_user_email(&pool, 1, "newalice@example.com").await?;

    // データの削除
    delete_user(&pool, 1).await?;

    Ok(())
}

まとめ


SQLxを使えば、非同期で安全にPostgreSQLへのCRUD操作が実現できます。SQLクエリはコンパイル時に検証されるため、実行前にエラーを発見でき、型安全性も保証されます。非同期処理を活用することで、I/O待ち時間を最小限に抑え、効率的なデータベース操作が可能になります。

DieselとSQLxの比較


RustでPostgreSQLを操作する際に人気のあるクレートがDieselとSQLxです。それぞれ異なる特徴と利点があるため、用途に応じて適切に選択することが重要です。ここでは、DieselとSQLxの特徴、メリット、デメリットを比較し、使い分けのポイントを解説します。

1. Dieselの特徴


DieselはRust向けの型安全なORM（Object-Relational Mapping）です。

  • 型安全なクエリビルダ：クエリをRustのコードで記述し、型安全にデータ操作が可能。
  • 同期処理：基本的に同期処理のみ対応。非同期処理には対応していません。
  • マイグレーションサポート：Diesel CLIを使って、データベーススキーマのマイグレーションが簡単に行える。
  • コンパイル時の安全性：Rustの型システムを活用し、クエリの型チェックをコンパイル時に行う。

Dieselのメリット：

  • 型安全なクエリビルダにより、SQLエラーをコンパイル時に検出可能。
  • ORMとして利用でき、Rustの構造体にマッピングしやすい。
  • マイグレーションがシンプルで扱いやすい。

Dieselのデメリット：

  • 非同期処理をサポートしていない。
  • 複雑なクエリの記述がやや冗長になることがある。

2. SQLxの特徴


SQLxは非同期対応のデータベースクライアントで、SQLを直接書くスタイルが特徴です。

  • 非同期処理：async/awaitで非同期クエリが可能。
  • コンパイル時クエリ検証：SQLクエリがコンパイル時に検証されるため、安全性が高い。
  • プレーンSQL：ORMではなく、SQLを直接記述するので、柔軟にクエリを書ける。
  • シンプルなAPI：シンプルで直感的なAPI設計。

SQLxのメリット：

  • 非同期クエリで高パフォーマンスを実現できる。
  • SQLを直接書けるため、複雑なクエリも柔軟に対応可能。
  • コンパイル時にSQLの検証ができるため、実行時エラーを防げる。

SQLxのデメリット：

  • ORM機能がないため、データベース操作がやや低レベルになる。
  • マイグレーションの機能は提供されていないため、外部ツールが必要。

3. DieselとSQLxの比較表

特徴DieselSQLx
クエリ記述方法クエリビルダ（Rustコード）プレーンSQL
処理方式同期非同期
型安全性クエリビルダによる型安全性コンパイル時のSQL検証による型安全性
マイグレーションDiesel CLIでサポート外部ツールが必要
柔軟性ORMとして構造体マッピングが容易SQLを直接書けるため複雑なクエリも柔軟に対応

4. 使い分けのポイント

  • Dieselが向いている場合：
  • 同期処理で十分なバックエンドアプリケーション。
  • 型安全なORMを使いたい場合。
  • マイグレーション機能を一緒に使いたい場合。
  • SQLxが向いている場合：
  • 非同期処理が必要なWebサービスや高トラフィックシステム。
  • SQLを直接書いて柔軟なクエリが必要な場合。
  • コンパイル時にSQLクエリを検証したい場合。

まとめ


DieselとSQLxはそれぞれ強力なデータベース操作クレートです。プロジェクトの要件や処理モデル（同期/非同期）に応じて、適切なクレートを選択することで、Rustでのデータベース操作を効率的かつ安全に行えます。

エラー処理とトラブルシューティング


RustでPostgreSQLに接続し、DieselやSQLxを使ってクエリを実行する際、エラーは避けられません。ここでは、よくあるエラーの原因とその対処法について解説します。

1. データベース接続エラー

エラーメッセージ例：

Error connecting to the database: failed to connect to server: No such file or directory

原因：

  • .envファイルのDATABASE_URLが正しく設定されていない。
  • PostgreSQLが起動していない。
  • 接続情報（ホスト名、ポート、ユーザー名、パスワード）が間違っている。

対処法：

  1. .envファイルのDATABASE_URLを確認し、正しい情報に修正する。
  2. PostgreSQLが起動しているか確認し、必要に応じて再起動する：
   sudo service postgresql restart
  1. PostgreSQLの設定ファイルpg_hba.confで接続許可が正しいか確認する。

2. マイグレーションエラー（Diesel）

エラーメッセージ例：

diesel migration run: Error: relation "users" does not exist

原因：

  • マイグレーションが正常に適用されていない。
  • テーブル定義が間違っている。

対処法：

  1. マイグレーションを再適用する：
   diesel migration redo
  1. マイグレーションファイルのSQLクエリが正しいか確認する。

3. クエリ実行エラー（Diesel・SQLx）

エラーメッセージ例：

error: column "email" does not exist

原因：

  • SQLクエリに誤りがある。
  • テーブルのスキーマが変更されているが、コードが古いスキーマを参照している。

対処法：

  1. SQLクエリが正しいか確認する。
  2. Dieselの場合、スキーマファイルschema.rsを再生成する：
   diesel print-schema > src/schema.rs

4. 非同期エラー（SQLx）

エラーメッセージ例：

Error: PoolTimedOut

原因：

  • 接続プールの最大接続数に達している。
  • 長時間クエリが実行されている。

対処法：

  1. max_connectionsを増やす：
   let pool = PgPoolOptions::new()
       .max_connections(10)  // 接続数を増やす
       .connect(&database_url)
       .await?;
  1. クエリの実行時間を短縮するか、適切にタイムアウトを設定する。

5. 型不一致エラー

エラーメッセージ例：

mismatched types: expected `i32`, found `i64`

原因：

  • Rustの構造体とデータベーススキーマの型が一致していない。

対処法：

  1. 構造体の型定義がデータベースのカラム型と一致しているか確認する。
  2. SQLxの場合、cargo sqlx prepareコマンドで型チェックを行う：
   cargo sqlx prepare

6. デバッグ時のTips

  • ロギングを有効化：クエリのログを出力してデバッグする。
  export RUST_LOG=debug
  • SQLクエリの出力：DieselやSQLxで実行されるクエリを確認する。
  • unwrap()を避ける：エラー処理には?演算子やmatchを使用し、エラーを適切に処理する。

まとめ


エラー処理とトラブルシューティングは、安全性が重視されるRustにおいて非常に重要です。エラーが発生した際には、エラーメッセージをしっかり読み取り、原因を特定して対処することで、効率的に問題を解決できます。

まとめ


本記事では、RustでPostgreSQLに接続し、クエリを実装する方法について解説しました。具体的には、DieselとSQLxという2つの主要なクレートを用いた接続方法とCRUD操作の実装方法を紹介しました。

  • Dieselでは、型安全なORMを活用し、同期的にデータベース操作を行う手順を解説しました。
  • SQLxでは、非同期処理をサポートし、プレーンSQLで柔軟にクエリを実行する方法を学びました。

また、よくあるエラーやトラブルシューティングのポイントについても説明し、エラー処理の重要性について理解を深めました。

Rustの高い安全性とパフォーマンス、PostgreSQLの信頼性を組み合わせることで、堅牢で効率的なデータベースアプリケーションを開発できます。要件に応じてDieselとSQLxを使い分け、プロジェクトに最適なソリューションを選択してください。

Rust
データベース PostgreSQL Rust sqlx Diesel

コメント

コメントする

目次
  1. RustとPostgreSQLの基本概要
    1. Rustとは何か
    2. PostgreSQLとは何か
    3. RustとPostgreSQLの組み合わせ
  2. RustでPostgreSQLを使うメリット
    1. 高い安全性
    2. 高パフォーマンス
    3. 非同期処理のサポート
    4. 強力な型システム
    5. 豊富なライブラリとエコシステム
    6. 信頼性の高い開発
  3. Dieselクレートを用いた接続方法
    1. 1. Dieselクレートのインストール
    2. 2. Diesel CLIのインストール
    3. 3. データベース設定ファイルの作成
    4. 4. Dieselの初期化
    5. 5. スキーマの定義とマイグレーション
    6. 6. コードでデータベースに接続
    7. 接続確認
  4. Dieselでクエリを実行する方法
    1. 1. テーブルのモデルとスキーマ定義
    2. 2. データの挿入（Create）
    3. 3. データの取得（Read）
    4. 4. データの更新（Update）
    5. 5. データの削除（Delete）
    6. 6. 使用例
    7. まとめ
  5. SQLxクレートを用いた接続方法
    1. 1. SQLxクレートのインストール
    2. 2. データベース設定ファイルの作成
    3. 3. データベースへの接続
    4. 4. 接続プールの解説
    5. 5. 接続確認
    6. 6. コードの補足
  6. SQLxでクエリを実行する方法
    1. 1. 必要なインポートと接続プール
    2. 2. データの挿入（Create）
    3. 3. データの取得（Read）
    4. 4. データの更新（Update）
    5. 5. データの削除（Delete）
    6. 6. クエリ関数の呼び出し
    7. まとめ
  7. DieselとSQLxの比較
    1. 1. Dieselの特徴
    2. 2. SQLxの特徴
    3. 3. DieselとSQLxの比較表
    4. 4. 使い分けのポイント
    5. まとめ
  8. エラー処理とトラブルシューティング
    1. 1. データベース接続エラー
    2. 2. マイグレーションエラー（Diesel）
    3. 3. クエリ実行エラー（Diesel・SQLx）
    4. 4. 非同期エラー（SQLx）
    5. 5. 型不一致エラー
    6. 6. デバッグ時のTips
    7. まとめ
  9. まとめ