MENU
  1. ホーム
  2. Rust
  3. RustでSQLxを使い構造化されたデータを型にマッピングする方法を徹底解説

RustでSQLxを使い構造化されたデータを型にマッピングする方法を徹底解説

Rust

Rustにおけるデータベース操作は、安全性とパフォーマンスを兼ね備えた非同期処理が求められます。その中でSQLxは、コンパイル時にSQLクエリを検証できる画期的な非同期データベースクライアントです。

SQLxを利用すると、クエリの結果をRustの型にマッピングすることで、型安全にデータベースの情報を操作できます。しかし、適切なマッピングを行うためには、Rustの型システムとSQLxの特性を理解する必要があります。

本記事では、SQLxの概要からセットアップ手順、具体的な型マッピングの方法や応用例まで詳しく解説します。Rustで効率的にデータベース操作を行うためのノウハウを習得し、バグの少ない堅牢なアプリケーションを開発するための一助としてください。

目次
  1. SQLxとは何か
    1. SQLxの主な特徴
    2. SQLxが選ばれる理由
  2. 構造化データのRust型へのマッピングの基本
    1. マッピングの基本概念
    2. マッピングのルール
    3. 自動マッピングの仕組み
    4. まとめ
  3. RustでのSQLxのセットアップ手順
    1. 1. Cargo.tomlへの依存関係追加
    2. 2. データベース接続設定
    3. 3. データベース接続の作成
    4. 4. データベースのマイグレーション
    5. 5. SQLx CLIのインストール
    6. まとめ
  4. SQLxのクエリ結果をRust型にマッピングする例
    1. シンプルなクエリ結果のマッピング
    2. クエリ結果を構造体にマッピング
    3. 複数のレコードを取得する
    4. マッピング時の注意点
    5. まとめ
  5. 複雑なクエリ結果をRust型にマッピングする方法
    1. 複数テーブルの結合結果のマッピング
    2. サブクエリを用いた結果のマッピング
    3. 注意点とベストプラクティス
    4. まとめ
  6. エラー処理と型マッピングのベストプラクティス
    1. SQLxでのエラーの種類
    2. 基本的なエラー処理の例
    3. エラー処理のポイント
    4. 型マッピングエラーの対処法
    5. ベストプラクティス
    6. まとめ
  7. SQLxのカスタム型マッピング
    1. カスタム型の基本概念
    2. カスタム型の定義例
    3. SQLx用のトレイト実装
    4. カスタム型を使った構造体
    5. カスタム型を用いたクエリ
    6. カスタム型マッピング時の注意点
    7. まとめ
  8. SQLxとRustでの型マッピングの応用例
    1. 1. ユーザー認証システム
    2. 2. REST APIエンドポイント
    3. 3. トランザクション処理
    4. 4. 複雑なデータ型のマッピング
    5. まとめ
  9. まとめ

SQLxとは何か


SQLxはRust向けの非同期データベースクライアントで、コンパイル時にSQLクエリを検証できる点が特徴です。これにより、実行時エラーを大幅に減らすことができます。

SQLxの主な特徴

  • 非同期処理対応：async/await構文をサポートし、高パフォーマンスな非同期データベース操作が可能。
  • コンパイル時クエリ検証：SQLクエリが正しいかコンパイル時に確認でき、SQLの構文エラーを早期に発見できる。
  • 型安全性：データベースの列とRustの型をマッピングすることで、型安全なデータ操作が可能。
  • 複数のデータベースサポート：PostgreSQL、MySQL、SQLite、MSSQLなど複数のデータベースをサポート。

SQLxが選ばれる理由


Rustの安全性とSQLxの静的検証を組み合わせることで、ランタイムエラーの可能性を低減します。さらに、非同期処理によりパフォーマンスの向上も見込めるため、ウェブアプリケーションやバックエンドAPI開発で広く利用されています。

SQLxは、シンプルなクエリから複雑なトランザクション処理まで幅広く対応しており、Rustのエコシステムに欠かせないツールの一つとなっています。

構造化データのRust型へのマッピングの基本

データベース操作を行う際、SQLのクエリ結果をRustの型にマッピングすることで、型安全にデータを扱えるようになります。これにより、データ型の不整合や誤った操作を防ぐことが可能です。

マッピングの基本概念


SQLxでは、クエリ結果の各列をRustの構造体に自動でマッピングします。構造体のフィールド名とクエリ結果のカラム名が一致している必要があります。

例えば、以下のようなSQLクエリと構造体があるとします。

SELECT id, name, age FROM users;

これをRustの型にマッピングするには、次のように構造体を定義します。

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

マッピングのルール

  1. フィールド名とカラム名の一致：
  • 構造体のフィールド名は、SQLクエリのカラム名と一致している必要があります。
  1. 型の互換性：
  • データベースのカラム型とRustのフィールド型が互換である必要があります。
    例えば、INTEGER型はi32に、TEXT型はStringにマッピングされます。

自動マッピングの仕組み


SQLxは#[derive(sqlx::FromRow)]マクロを利用して、構造体に対して自動的にマッピング処理を行います。これにより、クエリ結果を構造体として直接取得することができます。

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

まとめ


Rustの型にSQLxでクエリ結果をマッピングすることで、型安全性が向上し、バグの少ないコードが書けます。基本的なマッピングルールを理解し、適切に構造体を定義することが重要です。

RustでのSQLxのセットアップ手順

SQLxをRustプロジェクトで利用するには、いくつかのセットアップ手順が必要です。以下では、SQLxの導入から基本的な設定までを解説します。

1. Cargo.tomlへの依存関係追加


まず、Cargo.tomlにSQLxの依存関係を追加します。必要な機能や使用するデータベースによって、依存関係を選択します。

PostgreSQLを使用する場合の例：

[dependencies]
sqlx = { version = "0.6", features = ["runtime-tokio", "postgres", "macros", "chrono"] }
tokio = { version = "1", features = ["full"] }
  • runtime-tokio：Tokioランタイムを使用するための設定です。
  • postgres：PostgreSQLを使用するための機能です。
  • macros：SQLxのマクロ機能を有効化します。
  • chrono：日時型を扱うためのサポートです。

2. データベース接続設定


データベースに接続するための設定を行います。例えば、.envファイルに接続情報を記述します。

.envファイルの例：

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

3. データベース接続の作成


アプリケーションコードでデータベースへの接続を確立します。

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

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    dotenv::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!");
    Ok(())
}

4. データベースのマイグレーション


SQLxはマイグレーション機能も提供しています。以下のコマンドでマイグレーションを作成・適用します。

# 新しいマイグレーションファイルの作成
cargo sqlx migrate add create_users

# マイグレーションの適用
cargo sqlx migrate run

5. SQLx CLIのインストール


SQLx CLIをインストールして、コンパイル時のクエリ検証を有効化します。

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

まとめ


これでSQLxのセットアップが完了しました。依存関係の追加、接続設定、マイグレーションの実行を行うことで、安全かつ効率的なデータベース操作がRustで可能になります。

SQLxのクエリ結果をRust型にマッピングする例

SQLxを使ってデータベースのクエリ結果をRustの型にマッピングする方法を具体的なコード例と共に解説します。

シンプルなクエリ結果のマッピング

以下のusersテーブルがあると仮定します。

CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL,
    age INTEGER NOT NULL
);

このテーブルに対応するRustの構造体を定義します。

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

クエリ結果を構造体にマッピング

SQLxのquery_as!マクロを使い、クエリ結果をUser構造体にマッピングします。

use sqlx::{postgres::PgPoolOptions, Error};

#[tokio::main]
async fn main() -> Result<(), Error> {
    let database_url = "postgres://username:password@localhost/db_name";
    let pool = PgPoolOptions::new()
        .max_connections(5)
        .connect(&database_url)
        .await?;

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

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

複数のレコードを取得する

複数のユーザーを取得する場合は、fetch_allを使用します。

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

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

マッピング時の注意点

  1. フィールド名とカラム名の一致：
  • Rustの構造体のフィールド名はSQLクエリのカラム名と一致している必要があります。
  1. 型の互換性：
  • データベースのカラム型とRustの型は互換である必要があります。例えば、INTEGERはi32、TEXTはStringとしてマッピングされます。

まとめ

SQLxを使うことで、シンプルなクエリでも型安全にRustの構造体にマッピングできます。コンパイル時にクエリが検証されるため、エラーを早期に発見でき、データベース操作の安全性が向上します。

複雑なクエリ結果をRust型にマッピングする方法

複数のテーブルを結合したクエリやサブクエリなど、複雑なクエリ結果をRustの型にマッピングする方法を解説します。SQLxはこうした複雑なデータ操作にも対応しており、適切な構造体を用意することで効率よくデータを取得できます。

複数テーブルの結合結果のマッピング

例えば、usersテーブルとpostsテーブルがあり、ユーザーが書いた投稿を取得するシナリオを考えます。

usersテーブル:

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

postsテーブル:

CREATE TABLE posts (
    id SERIAL PRIMARY KEY,
    user_id INTEGER REFERENCES users(id),
    title TEXT NOT NULL
);

構造体の定義

結合結果に対応するRustの構造体を定義します。

#[derive(Debug, sqlx::FromRow)]
struct UserPost {
    user_id: i32,
    user_name: String,
    post_id: i32,
    post_title: String,
}

結合クエリの実行とマッピング

SQLxを使って複数テーブルの結合クエリを実行し、UserPost構造体にマッピングします。

use sqlx::{postgres::PgPoolOptions, Error};

#[tokio::main]
async fn main() -> Result<(), Error> {
    let database_url = "postgres://username:password@localhost/db_name";
    let pool = PgPoolOptions::new()
        .max_connections(5)
        .connect(&database_url)
        .await?;

    let results = sqlx::query_as!(
        UserPost,
        r#"
        SELECT users.id as user_id, users.name as user_name, posts.id as post_id, posts.title as post_title
        FROM users
        JOIN posts ON users.id = posts.user_id
        "#
    )
    .fetch_all(&pool)
    .await?;

    for result in results {
        println!("{:?}", result);
    }

    Ok(())
}

サブクエリを用いた結果のマッピング

サブクエリを使用した結果もRust型にマッピングできます。例えば、投稿数が2件以上のユーザーを取得するクエリです。

構造体の定義

#[derive(Debug, sqlx::FromRow)]
struct UserWithPostCount {
    user_name: String,
    post_count: i64,
}

サブクエリを用いたクエリ実行

let users = sqlx::query_as!(
    UserWithPostCount,
    r#"
    SELECT users.name as user_name, COUNT(posts.id) as post_count
    FROM users
    JOIN posts ON users.id = posts.user_id
    GROUP BY users.name
    HAVING COUNT(posts.id) >= 2
    "#
)
.fetch_all(&pool)
.await?;

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

注意点とベストプラクティス

  1. カラム名のエイリアス指定：
  • 複数テーブルの結合時には、フィールド名が重複しないようカラムにエイリアスを指定します。
  1. 適切な構造体の定義：
  • 結合するカラムに対応するフィールドを構造体で正確に定義することが重要です。
  1. クエリの検証：
  • SQLxのquery_as!マクロを使うことで、コンパイル時にクエリの正しさが検証されます。

まとめ

複雑なクエリ結果もSQLxを使えばRustの型に安全にマッピングできます。複数のテーブルを結合する場合やサブクエリを利用する場合でも、適切に構造体を定義し、カラム名のエイリアスを指定することで効率的なデータ取得が可能です。

エラー処理と型マッピングのベストプラクティス

SQLxを使ったRustアプリケーションでは、データベース操作におけるエラー処理が非常に重要です。適切なエラー処理を行うことで、予期しない動作やクラッシュを防ぎ、堅牢なアプリケーションを構築できます。

SQLxでのエラーの種類

SQLxでのエラーは、主に以下の種類に分類されます。

  • 接続エラー：データベースへの接続に失敗した場合。
  • クエリエラー：クエリの構文エラーやデータの取得エラー。
  • 型マッピングエラー：クエリ結果とRustの型が一致しない場合。

これらのエラーを適切に処理することで、アプリケーションの信頼性を高められます。

基本的なエラー処理の例

以下は、クエリ実行時のエラー処理の例です。

use sqlx::{postgres::PgPoolOptions, Error};

#[tokio::main]
async fn main() -> Result<(), Error> {
    let database_url = "postgres://username:password@localhost/db_name";
    let pool = PgPoolOptions::new()
        .max_connections(5)
        .connect(&database_url)
        .await
        .map_err(|e| {
            eprintln!("Database connection failed: {}", e);
            e
        })?;

    let user = sqlx::query!("SELECT id, name FROM users WHERE id = $1", 1)
        .fetch_optional(&pool)
        .await
        .map_err(|e| {
            eprintln!("Query failed: {}", e);
            e
        })?;

    match user {
        Some(user) => println!("User found: {} with ID: {}", user.name, user.id),
        None => println!("User not found"),
    }

    Ok(())
}

エラー処理のポイント

  1. エラーメッセージの明確化：
    エラーが発生した際に、どの処理で問題が起きたのか分かるようにメッセージを記述します。
  2. map_errを活用：
    map_errでエラーを処理し、エラー内容をロギングまたは整形して出力できます。
  3. fetch_oneとfetch_optionalの使い分け：
  • fetch_one：必ず1件の結果がある場合に使用し、結果がない場合はエラーになります。
  • fetch_optional：結果が0件または1件の場合に使用し、結果がない場合はNoneが返ります。

型マッピングエラーの対処法

型マッピングエラーが発生する主な原因は、データベースのカラム型とRustのフィールド型が一致していないことです。以下のポイントを確認しましょう。

  • データベーススキーマとRust構造体の型の一致：
    例：INTEGER型はi32に、TEXT型はStringにマッピングする。
  • カラム名とフィールド名の一致：
    クエリのカラム名と構造体のフィールド名が一致していることを確認します。

エラー例：

#[derive(sqlx::FromRow)]
struct User {
    id: i32,
    name: i32, // 誤り: 正しくは String
}

修正後：

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

ベストプラクティス

  1. エラーのロギング：
    エラーが発生した際に、適切にログを記録し、デバッグ情報を残します。
  2. リトライ処理：
    一時的な接続エラーに備えて、リトライ処理を実装するのも有効です。
  3. カスタムエラー型の利用：
    アプリケーション独自のエラー型を定義し、エラーの種類ごとに適切な処理を行うようにします。

まとめ

SQLxを使ったエラー処理では、接続エラー、クエリエラー、型マッピングエラーを適切に管理することが重要です。エラー処理を明確にし、ロギングやリトライ処理を組み込むことで、堅牢で信頼性の高いRustアプリケーションを構築できます。

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

SQLxでは、デフォルトの型以外にもカスタム型を定義し、データベースのクエリ結果をマッピングすることができます。これにより、特定のデータ型やビジネスロジックに沿った柔軟なデータ操作が可能になります。

カスタム型の基本概念

Rustでカスタム型を定義し、それをSQLxでマッピングするには、いくつかのステップが必要です：

  1. カスタム型の定義
  2. SQLxでカスタム型をマッピングするためのトレイトの実装
  3. クエリでカスタム型を使用する

カスタム型の定義例

たとえば、Emailという型をカスタム型として定義します。

use std::fmt;
use sqlx::postgres::PgHasArrayType;

// カスタム型の定義
#[derive(Debug, Clone)]
struct Email(String);

// Displayトレイトの実装
impl fmt::Display for Email {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.0)
    }
}

SQLx用のトレイト実装

SQLxでカスタム型を使用するには、TypeトレイトとFromRowトレイトを実装します。

use sqlx::Type;

// SQLxのTypeトレイトを実装
impl<'a> Type<'a> for Email {
    fn type_info() -> sqlx::postgres::PgTypeInfo {
        <String as Type>::type_info()
    }
}

カスタム型を使った構造体

Email型をフィールドに持つ構造体を定義します。

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

カスタム型を用いたクエリ

カスタム型を使用してデータベースからデータを取得する例です。

use sqlx::{postgres::PgPoolOptions, Error};

#[tokio::main]
async fn main() -> Result<(), Error> {
    let database_url = "postgres://username:password@localhost/db_name";
    let pool = PgPoolOptions::new()
        .max_connections(5)
        .connect(&database_url)
        .await?;

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

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

カスタム型マッピング時の注意点

  1. データ型の一致：
    データベースのカラムの型がRustのカスタム型に対応していることを確認してください。
  2. トレイトの実装：
    SQLxでカスタム型を使用するには、TypeやFromRowなどのトレイトを適切に実装する必要があります。
  3. エラーハンドリング：
    カスタム型のパース時にエラーが発生する可能性があるため、適切にエラー処理を行いましょう。

まとめ

SQLxのカスタム型マッピングを使うことで、データベースの値をより意味のあるRustの型に変換できます。これにより、型安全性が向上し、ビジネスロジックに沿ったデータ操作が可能になります。カスタム型の導入は、コードの可読性と保守性を向上させる強力な手段です。

SQLxとRustでの型マッピングの応用例

SQLxを使った型マッピングは、単純なデータベース操作だけでなく、さまざまな実用的なアプリケーションで応用することができます。ここでは、いくつかの応用例を通してSQLxの活用方法を解説します。

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

SQLxと型マッピングを使って、ユーザー認証システムを構築する例です。パスワードのハッシュ化と検証を組み合わせて、セキュアなログイン処理を行います。

ユーザーテーブルのスキーマ：

CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username TEXT NOT NULL,
    password_hash TEXT NOT NULL
);

Rustの構造体：

#[derive(Debug, sqlx::FromRow)]
struct User {
    id: i32,
    username: String,
    password_hash: String,
}

ログイン関数：

use sqlx::{postgres::PgPool, Error};
use argon2::{self, Config};

async fn login(pool: &PgPool, username: &str, password: &str) -> Result<bool, Error> {
    let user = sqlx::query_as!(
        User,
        "SELECT id, username, password_hash FROM users WHERE username = $1",
        username
    )
    .fetch_optional(pool)
    .await?;

    if let Some(user) = user {
        let matches = argon2::verify_encoded(&user.password_hash, password.as_bytes()).unwrap_or(false);
        Ok(matches)
    } else {
        Ok(false)
    }
}

2. REST APIエンドポイント

WebアプリケーションのバックエンドAPIでSQLxを使い、データベースから取得した情報をJSON形式で返す例です。

エンドポイントハンドラ：

use axum::{extract::Extension, Json};
use sqlx::postgres::PgPool;
use serde::Serialize;

#[derive(Serialize, sqlx::FromRow)]
struct User {
    id: i32,
    username: String,
}

async fn get_users(Extension(pool): Extension<PgPool>) -> Json<Vec<User>> {
    let users = sqlx::query_as!(User, "SELECT id, username FROM users")
        .fetch_all(&pool)
        .await
        .unwrap();

    Json(users)
}

このエンドポイントにアクセスすると、ユーザーリストがJSON形式で返されます。

3. トランザクション処理

複数のクエリを一括で実行し、途中でエラーが発生した場合にロールバックするトランザクション処理の例です。

トランザクションのコード：

use sqlx::{postgres::PgPool, Error};

async fn transfer_funds(pool: &PgPool, from_id: i32, to_id: i32, amount: i32) -> Result<(), Error> {
    let mut tx = pool.begin().await?;

    sqlx::query!(
        "UPDATE accounts SET balance = balance - $1 WHERE id = $2",
        amount,
        from_id
    )
    .execute(&mut *tx)
    .await?;

    sqlx::query!(
        "UPDATE accounts SET balance = balance + $1 WHERE id = $2",
        amount,
        to_id
    )
    .execute(&mut *tx)
    .await?;

    tx.commit().await?;
    Ok(())
}

4. 複雑なデータ型のマッピング

JSONB型のカラムをRustのserde_json::Valueにマッピングする例です。

テーブルスキーマ：

CREATE TABLE products (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL,
    attributes JSONB NOT NULL
);

Rustの構造体：

use serde_json::Value;

#[derive(Debug, sqlx::FromRow)]
struct Product {
    id: i32,
    name: String,
    attributes: Value,
}

クエリでの使用：

let product = sqlx::query_as!(
    Product,
    "SELECT id, name, attributes FROM products WHERE id = $1",
    1
)
.fetch_one(&pool)
.await?;

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

まとめ

SQLxとRustの型マッピングは、ユーザー認証、APIエンドポイント、トランザクション処理、複雑なデータ型の操作など、多岐にわたる場面で活用できます。これにより、安全で効率的なデータベース操作が可能になり、堅牢なアプリケーションを構築できます。

まとめ

本記事では、Rustの非同期データベースクライアントSQLxを使用して、構造化されたデータをRustの型にマッピングする方法について解説しました。基本的なセットアップから、シンプルなクエリ、複雑なクエリのマッピング、エラー処理、カスタム型のマッピング、そして応用例まで幅広く紹介しました。

SQLxを活用することで、コンパイル時にクエリの検証ができ、型安全にデータベースとやり取りできるため、実行時エラーを減らし、堅牢で信頼性の高いアプリケーションを構築できます。適切なエラー処理やカスタム型の導入により、さらに柔軟で保守しやすいコードが実現できます。

RustとSQLxの組み合わせをマスターし、安全で効率的なデータベース操作を行いましょう。

Rust
データベース Rust sqlx 型マッピング

コメント

コメントする

目次
  1. SQLxとは何か
    1. SQLxの主な特徴
    2. SQLxが選ばれる理由
  2. 構造化データのRust型へのマッピングの基本
    1. マッピングの基本概念
    2. マッピングのルール
    3. 自動マッピングの仕組み
    4. まとめ
  3. RustでのSQLxのセットアップ手順
    1. 1. Cargo.tomlへの依存関係追加
    2. 2. データベース接続設定
    3. 3. データベース接続の作成
    4. 4. データベースのマイグレーション
    5. 5. SQLx CLIのインストール
    6. まとめ
  4. SQLxのクエリ結果をRust型にマッピングする例
    1. シンプルなクエリ結果のマッピング
    2. クエリ結果を構造体にマッピング
    3. 複数のレコードを取得する
    4. マッピング時の注意点
    5. まとめ
  5. 複雑なクエリ結果をRust型にマッピングする方法
    1. 複数テーブルの結合結果のマッピング
    2. サブクエリを用いた結果のマッピング
    3. 注意点とベストプラクティス
    4. まとめ
  6. エラー処理と型マッピングのベストプラクティス
    1. SQLxでのエラーの種類
    2. 基本的なエラー処理の例
    3. エラー処理のポイント
    4. 型マッピングエラーの対処法
    5. ベストプラクティス
    6. まとめ
  7. SQLxのカスタム型マッピング
    1. カスタム型の基本概念
    2. カスタム型の定義例
    3. SQLx用のトレイト実装
    4. カスタム型を使った構造体
    5. カスタム型を用いたクエリ
    6. カスタム型マッピング時の注意点
    7. まとめ
  8. SQLxとRustでの型マッピングの応用例
    1. 1. ユーザー認証システム
    2. 2. REST APIエンドポイント
    3. 3. トランザクション処理
    4. 4. 複雑なデータ型のマッピング
    5. まとめ
  9. まとめ