MENU
  1. ホーム
  2. Rust
  3. RustでSQLxを用いた非同期データベース操作完全ガイド

RustでSQLxを用いた非同期データベース操作完全ガイド

Rust

Rustは、パフォーマンス、メモリ安全性、および並行性を重視するモダンなプログラミング言語です。非同期プログラミングがサポートされているため、効率的なI/O処理が可能で、Webサービスやデータベース操作といったタスクにも適しています。

SQLxはRust向けの非同期データベースクライアントライブラリで、コンパイル時にSQLクエリを検証できるという特徴があります。これにより、ランタイムエラーの可能性を大幅に減らし、型安全性を保ちながら効率的なデータベース操作を実現できます。

本記事では、SQLxを活用した非同期データベース操作の方法について、基本概念から具体的な手順、エラーハンドリング、実用的な応用例まで詳しく解説します。Rustで非同期処理を使いこなしたい方や、データベース操作を安全かつ効率的に行いたい方に最適な内容となっています。

目次

SQLxとは何か


SQLxはRust向けの非同期対応データベースクライアントライブラリです。コンパイル時にSQLクエリを検証するため、型安全性が高く、ランタイムエラーの発生を防ぐことができます。PostgreSQL、MySQL、SQLiteなど、複数のデータベースエンジンに対応しています。

SQLxの主な特徴

  1. 非同期処理サポート：async/await構文を用いた非同期データベース操作が可能です。
  2. コンパイル時のクエリ検証：クエリが正しいかコンパイル時にチェックされるため、データベース操作の安全性が向上します。
  3. 型安全性：クエリの結果がRustの型に自動的にマッピングされます。
  4. 複数のデータベースサポート：PostgreSQL、MySQL、SQLite、MSSQLといった主要データベースに対応しています。

SQLxがRustで人気の理由


Rustの非同期プログラミングモデルは、I/O処理を効率的に行うことができます。SQLxはこの非同期モデルに完全に適合しており、高パフォーマンスなデータベース操作を実現します。また、コンパイル時にSQL文を検証するため、誤ったクエリでアプリケーションがクラッシュするリスクを大幅に低減できます。

SQLxを導入することで、Rustアプリケーションにおけるデータベース操作の安全性と効率性が向上し、堅牢なシステムの構築が可能となります。

Rustの非同期処理の基礎知識


Rustは効率的な非同期処理をサポートするプログラミング言語です。従来のスレッドベースの並行処理に代わり、非同期モデルにより低オーバーヘッドで大量のI/Oタスクを処理できます。

非同期処理の基本概念


非同期処理では、タスクがI/O待ち状態になったときにスレッドをブロックせず、他のタスクが実行されるため、効率的なリソース利用が可能です。Rustでは、非同期処理をasyncとawaitキーワードを用いて記述します。

非同期関数の定義


非同期関数は、asyncキーワードを付けて定義します。

async fn fetch_data() -> String {
    // 非同期I/O処理
    "データ取得完了".to_string()
}

非同期タスクの実行


非同期関数は即座に実行されず、Futureというオブジェクトを返します。awaitキーワードで非同期タスクを待機します。

#[tokio::main]  // 非同期ランタイムの指定
async fn main() {
    let result = fetch_data().await;
    println!("{}", result);
}

非同期ランタイム


Rustの非同期処理を実行するには、非同期ランタイムが必要です。代表的なランタイムにはTokioとasync-stdがあります。

  • Tokio：高性能で多機能な非同期ランタイム。Webサービスやネットワークアプリケーションでよく使用されます。
  • async-std：シンプルで標準ライブラリのような使い勝手のランタイム。

非同期処理がデータベース操作に有効な理由


データベース操作はI/O待ち時間が発生するため、非同期処理を用いることでリソースを効率的に活用できます。SQLxとRustの非同期処理を組み合わせることで、同時に多数のデータベースクエリを処理し、アプリケーションのパフォーマンスを向上させることが可能です。

SQLxのセットアップ方法


SQLxをRustプロジェクトに導入するには、いくつかのステップが必要です。ここでは、基本的なインストール手順と環境設定について説明します。

Cargo.tomlにSQLxを追加


まず、Cargo.tomlファイルにSQLxの依存関係を追加します。使用するデータベースエンジンに応じて、必要な機能フラグを選択してください。

例えば、PostgreSQLを使用する場合は以下のように設定します：

[dependencies]
sqlx = { version = "0.7", features = ["runtime-tokio", "postgres", "macros", "chrono"] }
tokio = { version = "1", features = ["full"] }
  • runtime-tokio：Tokioランタイムを使用する場合の設定。
  • postgres：PostgreSQLドライバを使用する場合の設定。
  • macros：SQLxのクエリマクロを使用するための設定。
  • chrono：日付や時刻の操作をサポートするための設定。

データベースの準備


データベースに接続する前に、データベースサーバーをセットアップし、必要なテーブルを作成しておきます。

PostgreSQLの例：

CREATE DATABASE my_app;
\c my_app

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

環境変数で接続設定を管理


接続情報は環境変数に保存することで、セキュリティを向上させます。.envファイルを作成し、以下のように接続情報を記述します：

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

SQLxのデータベース接続


RustコードでSQLxを使ってデータベースに接続する方法は以下の通りです。

use sqlx::postgres::PgPoolOptions;

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    let database_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let pool = PgPoolOptions::new()
        .max_connections(5)
        .connect(&database_url)
        .await?;

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

SQLx CLIのインストール（オプション）


SQLxのクエリをコンパイル時に検証するためには、SQLx CLIが必要です。以下のコマンドでインストールできます：

cargo install sqlx-cli --no-default-features --features postgres

セットアップの確認


以下のコマンドで接続の確認を行います：

sqlx db create

これでSQLxのセットアップは完了です。Rustプロジェクトで安全かつ効率的に非同期データベース操作が行える準備が整いました。

SQLxでデータベース接続を行う方法


SQLxを用いてデータベースに接続するには、PgPool（PostgreSQL用の接続プール）やその他のデータベースごとの接続プールを使用します。ここでは、データベース接続の手順を詳しく解説します。

データベース接続の基本手順


以下は、PostgreSQLデータベースに接続する基本的なコード例です。

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

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    // 環境変数からデータベースURLを取得
    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!("データベースに接続しました!");
    Ok(())
}

コードの解説

  • env::var("DATABASE_URL")：環境変数からデータベース接続文字列を取得します。接続文字列の例：postgres://username:password@localhost/my_database。
  • PgPoolOptions::new().max_connections(5).connect(&database_url).await?：
  • max_connections(5)：接続プールの最大接続数を指定します。
  • connect：非同期でデータベースに接続し、接続プールを作成します。
  • tokio::main：非同期ランタイム（Tokio）を使用するためのマクロです。

環境変数の設定


.envファイルを作成し、データベースの接続情報を追加します。

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

この設定を反映するには、dotenvクレートを使用することが一般的です。

Cargo.tomlにdotenvを追加：

[dependencies]
dotenv = "0.15"

dotenvを読み込む：

dotenv::dotenv().ok();

データベース接続のエラーハンドリング


接続時にエラーが発生した場合、エラーメッセージを出力して処理を中断することができます。

let pool = PgPoolOptions::new()
    .max_connections(5)
    .connect(&database_url)
    .await
    .map_err(|e| {
        eprintln!("データベース接続エラー: {}", e);
        e
    })?;

その他のデータベースへの接続

SQLxは複数のデータベースエンジンに対応しています。接続プールの作成方法はデータベースごとに異なります。

  • MySQLの場合：
  use sqlx::mysql::MySqlPoolOptions;
  let pool = MySqlPoolOptions::new().connect(&database_url).await?;
  • SQLiteの場合：
  use sqlx::sqlite::SqlitePoolOptions;
  let pool = SqlitePoolOptions::new().connect(&database_url).await?;

まとめ


SQLxを使ったデータベース接続は、安全かつ効率的に非同期処理を行う基盤を提供します。接続プールを活用することで、パフォーマンスを向上させ、大規模なアプリケーションにも対応できます。

SQLxによるクエリの実行


SQLxを使ってRustで非同期クエリを実行する方法を解説します。データの挿入、取得、更新、削除の基本操作について、具体例を示しながら説明します。

データの挿入（INSERT）


以下は、SQLxを使用してデータベースに新しいレコードを挿入する例です。

use sqlx::postgres::PgPoolOptions;

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    let database_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let pool = PgPoolOptions::new().connect(&database_url).await?;

    let name = "Alice";
    let email = "alice@example.com";

    sqlx::query!(
        "INSERT INTO users (name, email) VALUES ($1, $2)",
        name,
        email
    )
    .execute(&pool)
    .await?;

    println!("データを挿入しました!");
    Ok(())
}

データの取得（SELECT）


データベースからレコードを取得する例です。取得したデータはRustの型にマッピングされます。

use sqlx::postgres::PgPoolOptions;

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    let database_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let pool = PgPoolOptions::new().connect(&database_url).await?;

    let users = sqlx::query!(
        "SELECT id, name, email FROM users"
    )
    .fetch_all(&pool)
    .await?;

    for user in users {
        println!("ID: {}, Name: {}, Email: {}", user.id, user.name, user.email);
    }

    Ok(())
}

データの更新（UPDATE）


既存のデータを更新する例です。

use sqlx::postgres::PgPoolOptions;

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    let database_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let pool = PgPoolOptions::new().connect(&database_url).await?;

    let user_id = 1;
    let new_email = "alice_new@example.com";

    sqlx::query!(
        "UPDATE users SET email = $1 WHERE id = $2",
        new_email,
        user_id
    )
    .execute(&pool)
    .await?;

    println!("データを更新しました!");
    Ok(())
}

データの削除（DELETE）


データベースからレコードを削除する例です。

use sqlx::postgres::PgPoolOptions;

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    let database_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let pool = PgPoolOptions::new().connect(&database_url).await?;

    let user_id = 1;

    sqlx::query!(
        "DELETE FROM users WHERE id = $1",
        user_id
    )
    .execute(&pool)
    .await?;

    println!("データを削除しました!");
    Ok(())
}

トランザクションの利用


複数のクエリを1つのトランザクション内で実行する方法です。

use sqlx::postgres::PgPoolOptions;

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    let database_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let pool = PgPoolOptions::new().connect(&database_url).await?;

    let mut transaction = pool.begin().await?;

    sqlx::query!(
        "INSERT INTO users (name, email) VALUES ($1, $2)",
        "Bob",
        "bob@example.com"
    )
    .execute(&mut transaction)
    .await?;

    sqlx::query!(
        "INSERT INTO users (name, email) VALUES ($1, $2)",
        "Charlie",
        "charlie@example.com"
    )
    .execute(&mut transaction)
    .await?;

    transaction.commit().await?;
    println!("トランザクションがコミットされました!");

    Ok(())
}

まとめ


SQLxを用いることで、Rustで安全かつ効率的にデータベースクエリを非同期で実行できます。挿入、取得、更新、削除、トランザクション処理といった基本操作を理解することで、実践的なデータベースアプリケーションを構築する準備が整います。

非同期クエリのエラーハンドリング


SQLxを使用する際には、エラーハンドリングを適切に行うことで、アプリケーションの信頼性を向上させることができます。ここでは、非同期クエリにおけるエラー処理の方法と、よくあるエラーへの対処法を紹介します。

基本的なエラーハンドリング


SQLxでクエリを実行する際にエラーが発生した場合、Result型を使用してエラー処理を行います。以下は、データベース接続時とクエリ実行時のエラーハンドリングの例です。

use sqlx::postgres::PgPoolOptions;

#[tokio::main]
async fn main() {
    let database_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");

    let pool = PgPoolOptions::new()
        .max_connections(5)
        .connect(&database_url)
        .await
        .map_err(|e| {
            eprintln!("データベース接続エラー: {}", e);
            e
        })
        .expect("接続に失敗しました");

    let result = sqlx::query!("SELECT * FROM users")
        .fetch_all(&pool)
        .await;

    match result {
        Ok(users) => {
            for user in users {
                println!("ID: {}, Name: {}, Email: {}", user.id, user.name, user.email);
            }
        }
        Err(e) => {
            eprintln!("クエリ実行エラー: {}", e);
        }
    }
}

エラーの種類と対処法


SQLxで発生する主なエラーとその対処方法を以下に示します。

1. 接続エラー


エラー内容：データベースへの接続に失敗した場合に発生します。
対処法：接続文字列が正しいか確認し、データベースが起動していることを確認します。

let pool = PgPoolOptions::new()
    .connect(&database_url)
    .await
    .map_err(|e| eprintln!("接続エラー: {}", e));

2. クエリ実行エラー


エラー内容：クエリの構文エラーや、存在しないテーブル・カラムを指定した場合に発生します。
対処法：クエリが正しいか、テーブルやカラムが存在するか確認します。

let result = sqlx::query!("SELECT * FROM invalid_table")
    .fetch_all(&pool)
    .await;

if let Err(e) = result {
    eprintln!("クエリエラー: {}", e);
}

3. データ型の不一致エラー


エラー内容：SQLクエリの結果がRustの型と一致しない場合に発生します。
対処法：SQLクエリの結果とRustの型が一致しているか確認します。

let user = sqlx::query!("SELECT id, name FROM users WHERE id = $1", 1)
    .fetch_one(&pool)
    .await?;

println!("User ID: {}, Name: {}", user.id, user.name);

クエリタイムアウトの設定


長時間クエリが実行され続けるのを防ぐため、タイムアウトを設定することができます。

use sqlx::postgres::PgPoolOptions;
use std::time::Duration;

let pool = PgPoolOptions::new()
    .acquire_timeout(Duration::from_secs(5))  // タイムアウトを5秒に設定
    .connect(&database_url)
    .await?;

エラー処理を関数化する


エラー処理を関数にまとめることで、コードの再利用性と可読性が向上します。

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

    for user in users {
        println!("ID: {}, Name: {}, Email: {}", user.id, user.name, user.email);
    }

    Ok(())
}

#[tokio::main]
async fn main() {
    let database_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let pool = PgPoolOptions::new().connect(&database_url).await.expect("接続失敗");

    if let Err(e) = get_users(&pool).await {
        eprintln!("エラー: {}", e);
    }
}

まとめ


SQLxの非同期クエリにおけるエラーハンドリングは、アプリケーションの安定性と保守性を高めます。接続エラー、クエリ実行エラー、データ型の不一致エラーなどを適切に処理し、必要に応じてタイムアウト設定やエラー処理の関数化を行うことで、堅牢なデータベース操作が可能になります。

SQLxと型安全性


SQLxは、Rustにおける型安全性を重視したデータベースクライアントライブラリです。SQLxを使用することで、コンパイル時にクエリとRustの型の整合性を検証でき、ランタイムエラーのリスクを大幅に減らすことができます。

型安全なクエリの特徴


SQLxはクエリの実行前に、データベースに対してクエリの検証を行います。この検証によって、以下の点が保証されます：

  1. SQL文の正当性：クエリに構文エラーがないことを確認します。
  2. カラムとRust型の一致：データベースのカラム型とRustの型が一致しているか検証します。
  3. 安全なバインドパラメータ：SQLインジェクションのリスクを防ぎます。

型安全なクエリの例


以下は、SQLxの型安全なクエリの具体例です。

use sqlx::postgres::PgPoolOptions;

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    let database_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let pool = PgPoolOptions::new().connect(&database_url).await?;

    let user_id = 1;

    let user = sqlx::query!(
        "SELECT id, name, email FROM users WHERE id = $1",
        user_id
    )
    .fetch_one(&pool)
    .await?;

    println!("ID: {}, Name: {}, Email: {}", user.id, user.name, user.email);

    Ok(())
}

型安全性を保証する仕組み

  1. sqlx::query!マクロ
    query!マクロはコンパイル時にクエリを検証します。データベース接続情報を基に、クエリの結果が正しいRustの型にマッピングされることを確認します。
   let result = sqlx::query!("SELECT id, name FROM users").fetch_one(&pool).await?;
  1. Rust型へのマッピング
    データベースのカラムの型はRustの型にマッピングされます。例えば： SQL型 Rust型 INTEGER i32 TEXT String BOOLEAN bool TIMESTAMP chrono::NaiveDateTime
  2. コンパイル時検証の例外
    クエリに問題があると、コンパイル時にエラーが表示されます。これにより、デプロイ前にエラーを修正できます。

型安全なクエリの利点

  1. ランタイムエラーの削減
    コンパイル時にクエリの型と構文が検証されるため、ランタイムエラーが減少します。
  2. メンテナンス性の向上
    型安全性が保証されることで、コード変更時のリファクタリングが容易になります。
  3. パフォーマンスの向上
    バグが少なくなることで、システム全体のパフォーマンスと安定性が向上します。

カスタム型へのマッピング


SQLxでは、カスタム構造体へのマッピングもサポートされています。

use sqlx::FromRow;

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

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    let database_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let pool = sqlx::postgres::PgPoolOptions::new().connect(&database_url).await?;

    let user = sqlx::query_as::<_, User>(
        "SELECT id, name, email FROM users WHERE id = $1"
    )
    .bind(1)
    .fetch_one(&pool)
    .await?;

    println!("{:?}", user);

    Ok(())
}

まとめ


SQLxの型安全なクエリ機能により、Rustでのデータベース操作は安全かつ堅牢になります。コンパイル時検証を活用することで、バグの少ないアプリケーションを開発し、メンテナンス性とパフォーマンスを向上させることができます。

SQLxの実用的な応用例


SQLxを使った実用的な応用例をいくつか紹介します。これらの例を参考にすることで、実際のプロジェクトで効率的に非同期データベース操作を行う方法を理解できます。

1. ユーザー認証システム


ユーザー登録と認証を行うシンプルなシステムをSQLxで実装する例です。

ユーザー登録：

use sqlx::postgres::PgPoolOptions;
use tokio;
use bcrypt::{hash, verify};

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    let database_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let pool = PgPoolOptions::new().connect(&database_url).await?;

    let username = "alice";
    let password = "password123";
    let hashed_password = hash(password, 12).expect("パスワードのハッシュ化に失敗しました");

    sqlx::query!(
        "INSERT INTO users (username, password) VALUES ($1, $2)",
        username,
        hashed_password
    )
    .execute(&pool)
    .await?;

    println!("ユーザー登録が完了しました!");
    Ok(())
}

ユーザー認証：

async fn authenticate_user(pool: &sqlx::PgPool, username: &str, password: &str) -> bool {
    if let Ok(user) = sqlx::query!("SELECT password FROM users WHERE username = $1", username)
        .fetch_one(pool)
        .await
    {
        verify(password, &user.password).unwrap_or(false)
    } else {
        false
    }
}

2. REST APIエンドポイントの作成


SQLxとWarpフレームワークを使用して、REST APIエンドポイントを作成する例です。

Cargo.tomlに依存関係を追加：

[dependencies]
warp = "0.3"
tokio = { version = "1", features = ["full"] }
sqlx = { version = "0.7", features = ["runtime-tokio", "postgres", "macros"] }

APIエンドポイントのコード：

use warp::Filter;
use sqlx::postgres::PgPoolOptions;

#[tokio::main]
async fn main() {
    let database_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let pool = PgPoolOptions::new().connect(&database_url).await.expect("接続失敗");

    let get_users = warp::path!("users")
        .and(warp::get())
        .and(with_db(pool.clone()))
        .and_then(fetch_users);

    warp::serve(get_users).run(([127, 0, 0, 1], 3030)).await;
}

async fn fetch_users(pool: sqlx::PgPool) -> Result<impl warp::Reply, warp::Rejection> {
    let users = sqlx::query!("SELECT id, name, email FROM users")
        .fetch_all(&pool)
        .await
        .map_err(|_| warp::reject::not_found())?;

    Ok(warp::reply::json(&users))
}

fn with_db(pool: sqlx::PgPool) -> impl Filter<Extract = (sqlx::PgPool,), Error = std::convert::Infallible> + Clone {
    warp::any().map(move || pool.clone())
}

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


大量のデータを扱う場合、ページネーション（ページ分割表示）が必要です。

use sqlx::postgres::PgPoolOptions;

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    let database_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let pool = PgPoolOptions::new().connect(&database_url).await?;

    let page = 1;
    let items_per_page = 10;
    let offset = (page - 1) * items_per_page;

    let users = sqlx::query!(
        "SELECT id, name, email FROM users LIMIT $1 OFFSET $2",
        items_per_page as i64,
        offset as i64
    )
    .fetch_all(&pool)
    .await?;

    for user in users {
        println!("ID: {}, Name: {}, Email: {}", user.id, user.name, user.email);
    }

    Ok(())
}

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


複数のクエリをまとめて処理し、失敗時にはロールバックする例です。

use sqlx::postgres::PgPoolOptions;

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    let database_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
    let pool = PgPoolOptions::new().connect(&database_url).await?;

    let mut transaction = pool.begin().await?;

    sqlx::query!("INSERT INTO orders (user_id, amount) VALUES ($1, $2)", 1, 1000)
        .execute(&mut transaction)
        .await?;

    sqlx::query!("UPDATE users SET balance = balance - $1 WHERE id = $2", 1000, 1)
        .execute(&mut transaction)
        .await?;

    transaction.commit().await?;
    println!("トランザクションが成功しました!");

    Ok(())
}

まとめ


SQLxを活用することで、ユーザー認証、REST API、ページネーション、トランザクション処理といった実践的なデータベース操作がRustで効率よく実装できます。非同期処理と型安全性を組み合わせることで、堅牢で高パフォーマンスなアプリケーションを構築できるのがSQLxの大きな魅力です。

まとめ


本記事では、RustにおけるSQLxを用いた非同期データベース操作について解説しました。SQLxは非同期処理に対応し、コンパイル時にクエリの型安全性を検証できるため、データベース操作の信頼性が向上します。

導入からセットアップ、基本的なクエリの実行、エラーハンドリング、型安全性、そして実用的な応用例まで紹介しました。SQLxを活用することで、ユーザー認証やREST API、トランザクション処理など、さまざまな場面で効率的かつ安全にデータベース操作が可能です。

RustとSQLxを組み合わせることで、パフォーマンスと安全性を兼ね備えた堅牢なアプリケーションを構築できるため、今後の開発にぜひ役立ててください。

Rust
データベース 非同期処理 Rust sqlx

コメント

コメントする

目次