Rust Oracle数据库操作宏库oracle_procmacro使用指南

简介

oracle_procmacro是一个简化Rust与Oracle数据库交互的过程宏库，它通过提供声明式宏来减少样板代码，使Oracle数据库操作更加简洁直观。

主要特性

• 自动处理连接池管理
• 简化SQL查询执行
• 类型安全的参数绑定
• 自动结果集映射
• 支持事务操作

安装

在Cargo.toml中添加依赖：

[dependencies]
oracle_procmacro = "0.1"
tokio = { version = "1.0", features = ["full"] }

基本使用方法

1. 建立连接

use oracle_procmacro::oracle_connect;

#[oracle_connect(
    url = "oracle://username:password@localhost:1521/ORCLCDB",
    pool_size = 5
)]
struct DbConnection;

2. 执行查询

use oracle_procmacro::oracle_query;

#[oracle_query(
    sql = "SELECT id, name, salary FROM employees WHERE department = :dept",
    fetch = "all"
)]
struct GetEmployeesByDept {
    dept: String,
}

3. 使用查询

#[tokio::main]
async fn main() {
    let conn = DbConnection::new().await;
    let employees = GetEmployeesByDept { dept: "IT".to_string() }
        .execute(&conn)
        .await
        .unwrap();
    
    for emp in employees {
        println!("ID: {}, Name: {}, Salary: {}", emp.id, emp.name, emp.salary);
    }
}

高级用法

事务支持

use oracle_procmacro::oracle_transaction;

#[oracle_transaction]
async fn update_employee_salary(conn: &DbConnection, emp_id: i32, new_salary: f64) -> Result<(), String> {
    #[oracle_query(sql = "UPDATE employees SET salary = :salary WHERE id = :id")]
    struct UpdateSalary {
        id: i32,
        salary: f64,
    }
    
    UpdateSalary { id: emp_id, salary: new_salary }
        .execute(conn)
        .await
        .map_err(|e| e.to_string())?;
    
    Ok(())
}

批量操作

use oracle_procmacro::oracle_batch;

#[oracle_batch(
    sql = "INSERT INTO employees (id, name, department) VALUES (:id, :name, :dept)",
    batch_size = 100
)]
struct BatchInsertEmployee {
    id: i32,
    name: String,
    dept: String,
}

#[tokio::main]
async fn main() {
    let conn = DbConnection::new().await;
    let employees = vec![
        BatchInsertEmployee { id: 1, name: "Alice".to_string(), dept: "IT".to_string() },
        BatchInsertEmployee { id: 2, name: "Bob".to_string(), dept: "HR".to_string() },
        // ...更多记录
    ];
    
    BatchInsertEmployee::execute_batch(&conn, employees).await.unwrap();
}

自定义类型映射

use oracle_procmacro::oracle_type_mapping;

#[oracle_type_mapping]
mod custom_types {
    pub struct MyCustomType(String);
    
    impl From<oracle::SqlValue> for MyCustomType {
        fn from(value: oracle::SqlValue) -> Self {
            MyCustomType(value.get_string().unwrap())
        }
    }
    
    impl Into<oracle::SqlValue> for MyCustomType {
        fn into(self) -> oracle::SqlValue {
            oracle::SqlValue::String(self.0)
        }
    }
}

错误处理

所有操作都返回Result类型，可以方便地进行错误处理：

#[tokio::main]
async fn main() {
    let conn = DbConnection::new().await;
    let result = GetEmployeesByDept { dept: "IT".to_string() }
        .execute(&conn)
        .await;
    
    match result {
        Ok(employees) => {
            // 处理成功结果
        },
        Err(e) => {
            eprintln!("查询失败: {}", e);
            // 错误处理逻辑
        }
    }
}

性能提示

1. 连接池大小应根据应用负载调整
2. 批量操作比单条操作效率更高
3. 复杂查询考虑使用存储过程

完整示例

以下是一个完整的Rust程序示例，展示了如何使用oracle_procmacro库进行Oracle数据库操作：

use oracle_procmacro::{oracle_connect, oracle_query, oracle_batch, oracle_transaction};

// 1. 建立数据库连接
#[oracle_connect(
    url = "oracle://username:password@localhost:1521/ORCLCDB",
    pool_size = 5
)]
struct DbConnection;

// 2. 定义查询结构体
#[oracle_query(
    sql = "SELECT id, name, salary FROM employees WHERE department = :dept",
    fetch = "all"
)]
struct GetEmployeesByDept {
    dept: String,
}

// 3. 定义批量插入结构体
#[oracle_batch(
    sql = "INSERT INTO employees (id, name, department) VALUES (:id, :name, :dept)",
    batch_size = 100
)]
struct BatchInsertEmployee {
    id: i32,
    name: String,
    dept: String,
}

// 4. 定义事务操作函数
#[oracle_transaction]
async fn transfer_employee(
    conn: &DbConnection,
    emp_id: i32,
    new_dept: String,
    new_salary: f64
) -> Result<(), String> {
    #[oracle_query(sql = "UPDATE employees SET department = :dept WHERE id = :id")]
    struct UpdateDept {
        id: i32,
        dept: String,
    }
    
    #[oracle_query(sql = "UPDATE employees SET salary = :salary WHERE id = :id")]
    struct UpdateSalary {
        id: i32,
        salary: f64,
    }
    
    UpdateDept { id: emp_id, dept: new_dept }
        .execute(conn)
        .await
        .map_err(|e| e.to_string())?;
    
    UpdateSalary { id: emp_id, salary: new_salary }
        .execute(conn)
        .await
        .map_err(|e| e.to_string())?;
    
    Ok(())
}

#[tokio::main]
async fn main() {
    // 初始化连接
    let conn = DbConnection::new().await;
    
    // 示例1: 查询操作
    let it_employees = GetEmployeesByDept { dept: "IT".to_string() }
        .execute(&conn)
        .await
        .unwrap();
    
    println!("IT部门员工:");
    for emp in it_employees {
        println!("ID: {}, Name: {}, Salary: {}", emp.id, emp.name, emp.salary);
    }
    
    // 示例2: 批量插入
    let new_employees = vec![
        BatchInsertEmployee { id: 101, name: "Charlie".to_string(), dept: "Finance".to_string() },
        BatchInsertEmployee { id: 102, name: "David".to_string(), dept: "Marketing".to_string() },
        BatchInsertEmployee { id: 103, name: "Eve".to_string(), dept: "Engineering".to_string() },
    ];
    
    BatchInsertEmployee::execute_batch(&conn, new_employees).await.unwrap();
    println!("成功批量插入员工记录");
    
    // 示例3: 事务操作
    match transfer_employee(&conn, 101, "Engineering".to_string(), 85000.0).await {
        Ok(_) => println!("员工部门转移成功"),
        Err(e) => eprintln!("事务失败: {}", e),
    }
}

这个完整示例展示了：

1. 数据库连接池的建立
2. 基本查询操作
3. 批量数据插入
4. 事务处理
5. 错误处理

您可以根据实际需求调整SQL语句和参数，这个宏库可以大大简化Oracle数据库操作代码。