SQLx是一個Rust語言的異步SQL執行庫，它支持多種數據庫，包括MySQL、PostgreSQL、SQLite等。本教程將以MySQL數據庫為例，介紹SQLx在Rust語言中的基礎用法和進階用法。

基礎用法

要使用SQLx，需要在Cargo.toml文件中添加以下依賴：

[dependencies]
sqlx = { version = "0.6", features = ["mysql", "runtime-tokio-rustls"] }
tokio = { version = "1", features = ["full"] }

連接數據庫

在使用SQLx之前，需要先連接數據庫。SQLx提供了兩種方式連接MySQL數據庫：使用URL連接和使用配置文件連接。

URL連接

使用URL連接時，需要在代碼中指定連接字符串，例如：

use sqlx::mysql::MySqlPoolOptions;

#[tokio::main]
async fn main() - > Result< (), sqlx::Error > {
    let pool = MySqlPoolOptions::new()
        .max_connections(5)
        .connect("mysql://username:password@hostname:port/database")
        .await?;
    // ...
    Ok(())
}

其中，username和password是數據庫用戶名和密碼，hostname是數據庫主機名，port是數據庫端口號，database是要連接的數據庫名。

配置文件連接

使用配置文件連接時，需要在項目根目錄下創建一個名為.env的文件，并在其中指定連接信息，例如：

DATABASE_URL=mysql://username:password@hostname:port/database

然后在代碼中使用dotenv庫加載.env文件，并使用sqlx::MySqlPool::connect_dotenv()方法連接數據庫，例如：

use sqlx::mysql::MySqlPoolOptions;

#[tokio::main]
async fn main() - > Result< (), sqlx::Error > {
    dotenv::dotenv().ok();
    let pool = MySqlPoolOptions::new()
        .max_connections(5)
        .connect_dotenv()
        .await?;
    // ...
    Ok(())
}

查詢數據

連接成功后，就可以使用SQLx執行SQL查詢語句了。SQLx提供了兩種方式執行SQL查詢語句：使用query()方法和使用query_as()方法。

使用query()方法

使用query()方法執行SQL查詢語句時，需要手動指定返回結果的類型，例如：

use sqlx::{MySqlPool, Row};

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

#[tokio::main]
async fn main() - > Result< (), sqlx::Error > {
    let pool = MySqlPool::connect("mysql://username:password@hostname:port/database").await?;
    let mut conn = pool.acquire().await?;

    let mut rows = sqlx::query("SELECT id, name FROM users")
        .map(|row: sqlx::mysql::MySqlRow| {
            User {
                id: row.get(0),
                name: row.get(1),
            }
        })
        .fetch_all(&mut conn)
        .await?;

    for row in rows.iter() {
        println!("{:?}", row);
    }

    Ok(())
}

使用query_as()方法

使用query_as()方法執行SQL查詢語句時，可以自動將返回結果轉換為指定類型的結構體，例如：

use sqlx::{MySqlPool, FromRow};

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

#[tokio::main]
async fn main() - > Result< (), sqlx::Error > {
    let pool = MySqlPool::connect("mysql://username:password@hostname:port/database").await?;
    let mut conn = pool.acquire().await?;

    let mut rows = sqlx::query_as::< _, User >("SELECT id, name FROM users")
        .fetch_all(&mut conn)
        .await?;

    for row in rows.iter() {
        println!("{:?}", row);
    }

    Ok(())
}

插入數據

使用SQLx插入數據時，可以使用execute()方法或execute_with()方法。

使用execute()方法

使用execute()方法插入數據時，需要手動指定插入的數據，例如：

use sqlx::{MySqlPool, Row};

#[derive(Debug)]
struct User {
    name: String,
}

#[tokio::main]
async fn main() - > Result< (), sqlx::Error > {
    let pool = MySqlPool::connect("mysql://username:password@hostname:port/database").await?;
    let mut conn = pool.acquire().await?;

    let user = User {
        name: "John".to_string(),
    };

    let result = sqlx::query("INSERT INTO users (name) VALUES (?)")
        .bind(user.name)
        .execute(&mut conn)
        .await?;

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

    Ok(())
}

使用execute_with()方法

使用execute_with()方法插入數據時，可以使用結構體自動映射的特性，例如：

use sqlx::{MySqlPool, FromRow};

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

#[tokio::main]
async fn main() - > Result< (), sqlx::Error > {
    let pool = MySqlPool::connect("mysql://username:password@hostname:port/database").await?;
    let mut conn = pool.acquire().await?;

    let user = User {
        name: "John".to_string(),
    };

    let result = sqlx::query_with::< _, User >("INSERT INTO users (name) VALUES (?)", user)
        .execute(&mut conn)
        .await?;

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

    Ok(())
}

更新數據

使用SQLx更新數據時，可以使用execute()方法或execute_with()方法。

使用execute()方法

使用execute()方法更新數據時，需要手動指定更新的條件和更新的數據，例如：

use sqlx::{MySqlPool, Row};

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

#[tokio::main]
async fn main() - > Result< (), sqlx::Error > {
    let pool = MySqlPool::connect("mysql://username:password@hostname:port/database").await?;
    let mut conn = pool.acquire().await?;

    let user = User {
        id: 1,
        name: "John".to_string(),
    };

    let result = sqlx::query("UPDATE users SET name = ? WHERE id = ?")
        .bind(user.name)
        .bind(user.id)
        .execute(&mut conn)
        .await?;

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

    Ok(())
}

使用execute_with()方法

使用execute_with()方法更新數據時，可以使用結構體自動映射的特性，例如：

use sqlx::{MySqlPool, FromRow};

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

#[tokio::main]
async fn main() - > Result< (), sqlx::Error > {
    let pool = MySqlPool::connect("mysql://username:password@hostname:port/database").await?;
    let mut conn = pool.acquire().await?;

    let user = User {
        id: 1,
        name: "John".to_string(),
    };

    let result = sqlx::query_with::< _, User >("UPDATE users SET name = :name WHERE id = :id", user)
        .execute(&mut conn)
        .await?;

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

    Ok(())
}

刪除數據

使用SQLx刪除數據時，可以使用execute()方法或execute_with()方法。

使用execute()方法

使用execute()方法刪除數據時，需要手動指定刪除的條件，例如：

use sqlx::{MySqlPool, Row};

#[tokio::main]
async fn main() - > Result< (), sqlx::Error > {
    let pool = MySqlPool::connect("mysql://username:password@hostname:port/database").await?;
    let mut conn = pool.acquire().await?;

    let result = sqlx::query("DELETE FROM users WHERE id = ?")
        .bind(1)
        .execute(&mut conn)
        .await?;

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

    Ok(())
}

使用execute_with()方法

使用execute_with()方法刪除數據時，可以使用結構體自動映射的特性，例如：

use sqlx::{MySqlPool, FromRow};

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

#[tokio::main]
async fn main() - > Result< (), sqlx::Error > {
    let pool = MySqlPool::connect("mysql://username:password@hostname:port/database").await?;
    let mut conn = pool.acquire().await?;

    let user = User {
        id: 1,
    };

    let result = sqlx::query_with::< _, User >("DELETE FROM users WHERE id = :id", user)
        .execute(&mut conn)
        .await?;

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

    Ok(())
}

進階用法

事務

使用SQLx執行事務時，可以使用begin()方法開始事務，使用commit()方法提交事務，使用rollback()方法回滾事務。

use sqlx::{MySqlPool, Transaction};

#[derive(Debug)]
struct User {
    name: String,
}

#[tokio::main]
async fn main() - > Result< (), sqlx::Error > {
    let pool = MySqlPool::connect("mysql://username:password@hostname:port/database").await?;
    let mut conn = pool.acquire().await?;

    let mut tx = conn.begin().await?;

    let user = User {
        name: "John".to_string(),
    };

    let result = sqlx::query("INSERT INTO users (name) VALUES (?)")
        .bind(user.name)
        .execute(&mut tx)
        .await?;

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

    tx.commit().await?;

    Ok(())
}

連接池

使用SQLx連接池時，可以使用PoolOptions::new()方法創建連接池，并使用acquire()方法獲取連接。

use sqlx::{MySqlPool, PoolOptions};

#[tokio::main]
async fn main() - > Result< (), sqlx::Error > {
    let pool = MySqlPool::connect("mysql://username:password@hostname:port/database").await?;
    let mut conn = pool.acquire().await?;

    let pool = MySqlPool::builder()
        .max_size(5)
        .build("mysql://username:password@hostname:port/database")
        .await?;

    let mut conn = pool.acquire().await?;

    // ...

    Ok(())
}

總結

本教程介紹了SQLx在Rust語言中的基礎用法和進階用法，包括連接數據庫、查詢數據、插入數據、更新數據、刪除數據、事務和連接池等。SQLx是一個簡單易用的異步SQL執行庫，可以幫助Rust開發者快速地與多種數據庫進行交互。