pgbatis 0.1.51

/*
 * @Author: venom
 * @Date: 2021-08-13 16:42:05
 * @LastEditors: BuddyCoder
 * @LastEditTime: 2026-05-27 10:57:42
 * @Description:
 * @FilePath: /CHX/Users/caixiaocong/workspace/rust/rust_crates/pgbatis/src/lib.rs
 * MIT
 */

//! # pgbatis — 轻量级异步 PostgreSQL CRUD 辅助库
//!
//! 基于 `tokio-postgres` + `deadpool-postgres`，通过派生宏 `#[derive(PGCRUD)]`
//! 快速为结构体生成 CRUD 能力，并提供链式条件构造器（[`Wrapper`]）和可选逻辑删除支持。
//!
//! ## 快速开始
//!
//! ```rust,ignore
//! use pgbatis::pgmacro::PGCRUD;
//! use serde::{Deserialize, Serialize};
//!
//! #[derive(PGCRUD, Serialize, Deserialize, Clone, Debug, Default)]
//! pub struct User {
//!     pub id: Option<String>,
//!     pub name: Option<String>,
//!     pub age: Option<i32>,
//! }
//!
//! // 1. 初始化连接（必须在任何数据库操作之前调用）
//! pgbatis::link("127.0.0.1", 5432, "user", "pass", "mydb", 10).await?;
//!
//! // 2. 保存
//! let user = User { id: Some("1".into()), name: Some("Alice".into()), age: Some(30) };
//! pgbatis::save(&user, None, None).await?;
//!
//! // 3. 条件查询
//! use pgbatis::Wrapper;
//! let wrapper = Wrapper::new().eq(&"name", &"Alice").set_pages(1, 10);
//! let page = pgbatis::fetch_page::<User>(wrapper, None, None).await?;
//! ```
//!
//! ## 核心概念
//!
//! - **Parameters trait**：实体必须实现的 trait，通常由 `#[derive(PGCRUD)]` 自动生成
//! - **Wrapper**：链式 WHERE 条件、排序、分页构造器
//! - **逻辑删除**：默认启用，读操作自动过滤已删除数据，`remove()` 默认软删除

use lazy_static::lazy_static;
use std::collections::HashMap;
use std::sync::Mutex;
use tokio_postgres::Error;

use deadpool_postgres::{Manager, ManagerConfig, Pool, RecyclingMethod};
use once_cell::sync::Lazy;
pub use pgmacro;
pub use plugin::logic_delete::LogicDelete;
pub use plugin::logic_delete::LogicDeletePlugin;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::fmt::Debug;
use tokio::sync::OnceCell;
pub use tokio_postgres;
pub use tokio_postgres::{types::ToSql, Client, NoTls, Row};
pub mod plugin;
pub mod wrapper;
pub use wrapper::Wrapper;
pub mod unit;
use tracing::{debug, error, info, trace};

//迫不得已，当连接断开之后 无法重新连接。只能启用连接一次 重连一次的做法。每次都生成独立的连接
//性能必定受损，罢了罢了。虽然 deadpool 是一个不错的连接池
static EMPTY_STRING: &'static str = r#""#;
/// 日志对齐空格常量，用于格式化 SQL 日志输出中的缩进。
pub const LOG_SPACE: &'static str =
    "                                                                ";
lazy_static! {
    static  ref EXCLUSION_TABLE: Mutex<Vec<String>>  = {
        Mutex::new(Vec::new())
    };
}

static DATABASE_POOL: Lazy<Pgbatis> = Lazy::new(|| {
    let m = Pgbatis::new();
    let exclusion_table_m = EXCLUSION_TABLE.lock().unwrap();
    let exclusion_table = exclusion_table_m.clone();
    {
        let mut lp = m.logic_plugin.lock().unwrap();
        *lp = Some(Box::new(LogicDeletePlugin::new_opt(
            "is_deleted",
            1,
            0,
            exclusion_table,
        )));
        info!("pgbatis logic_delete plugin initialized in Lazy (is_deleted)");
    }
    m
});

/// 实体参数 trait —— 定义 CRUD 操作所需的元数据与 SQL 生成能力。
///
/// 通常不手动实现，由 `#[derive(PGCRUD)]` 派生宏自动生成。
///
/// # 示例
///
/// ```rust,ignore
/// #[derive(PGCRUD, Serialize, Deserialize, Clone, Debug, Default)]
/// pub struct User {
///     pub id: Option<String>,
///     pub name: Option<String>,
/// }
/// ```
pub trait Parameters {
    /// 返回表名，支持可选的 `prefix`（前缀）和 `suffix`（后缀）。
    ///
    /// 最终表名格式：`{prefix_}{table_name}_{suffix}`（prefix/suffix 为 None 时省略对应部分）。
    fn get_table_name(prefix: Option<String>, suffix: Option<String>) -> String;

    /// 返回以逗号分隔的字段列表字符串，用于 SELECT 子句。
    fn get_field_list() -> String;

    /// 生成 INSERT 语句及其参数。
    ///
    /// # 返回
    /// - `Ok((sql, args))` — SQL 字符串与参数数组
    /// - `Err(msg)` — 生成失败的原因
    fn gen_save(
        &self,
        prefix: Option<String>,
        suffix: Option<String>,
    ) -> Result<(String, Vec<&(dyn ToSql + Sync)>), String>;

    /// 生成 UPDATE 语句、参数及参数起始编号。
    ///
    /// # 返回
    /// - `Ok((sql, args, args_start_number))` — SQL 字符串、参数数组、占位符起始编号
    /// - `Err(msg)` — 生成失败的原因
    fn gen_update(
        &self,
        prefix: Option<String>,
        suffix: Option<String>,
    ) -> Result<(String, Vec<&(dyn ToSql + Sync)>, u32), String>;

    /// 将单行查询结果转换为实体实例。
    ///
    /// 由派生宏自动实现，根据字段顺序从 `Row` 中提取值。
    fn return_one(rows: Row) -> Self;

    /// 将多行查询结果批量转换为实体列表。
    ///
    /// 默认实现逐行调用 [`return_one`](Parameters::return_one)。
    fn return_list(rows: Vec<Row>) -> Vec<Self>
    where
        Self: Sized,
    {
        let mut result_list = Vec::new();
        for row in rows {
            result_list.push(Self::return_one(row))
        }

        return result_list;
    }
}

/// 列名提取 trait，用于将类型安全的列标识转换为 SQL 列名字符串。
///
/// 通常与 [`check_row_by_column`] 等需要指定列名的 API 配合使用。
///
/// # 示例
///
/// ```rust,ignore
/// struct NameColumn;
/// impl ColumnExt for NameColumn {
///     fn get(&self) -> &'static str { "name" }
/// }
/// ```
pub trait ColumnExt {
    /// 返回该列在数据库中的列名。
    fn get(&self) -> &'static str;
}

/// 全局数据库连接管理器。
///
/// 持有连接池（[`OnceCell<Pool>`]）和可选的逻辑删除插件。
/// 通过全局懒初始化单例 [`DATABASE_POOL`] 使用，通常不直接实例化。
///
/// # 字段
/// - `pools`: 连接池，通过 [`link`] 初始化
/// - `logic_plugin`: 逻辑删除插件，默认使用 [`LogicDeletePlugin`]
pub struct Pgbatis {
    /// PostgreSQL 连接池，通过 [`link`] 初始化。
    pub pools: OnceCell<Pool>,
    /// 可选的逻辑删除插件，默认使用 [`LogicDeletePlugin`]（字段 `is_deleted`）。
    pub logic_plugin: Mutex<Option<Box<dyn LogicDelete>>>,
}

impl Pgbatis {
    /// 创建新的 `Pgbatis` 实例（等同于 [`new_with_opt`](Pgbatis::new_with_opt)）。
    pub fn new() -> Self {
        return Self::new_with_opt();
    }

    /// 创建带默认配置的 `Pgbatis` 实例。
    ///
    /// 连接池和逻辑删除插件均未初始化，需后续调用 [`link`] 完成设置。
    pub fn new_with_opt() -> Self {
        return Self {
            pools: OnceCell::new(),
            logic_plugin: Mutex::new(None),
        };
    }

    /// 设置逻辑删除插件。
    ///
    /// 传入 `None` 可禁用逻辑删除。传入自定义实现可替换默认行为。
    ///
    /// # 参数
    /// - `arg`: 实现了 [`LogicDelete`] 的插件实例，或 `None` 禁用
    pub fn set_logic_delete(&mut self, arg: Option<impl LogicDelete + 'static>) {
        let mut guard = self.logic_plugin.lock().unwrap();
        *guard = arg.map(|v| Box::new(v) as Box<dyn LogicDelete>);
    }
}

fn trace_exec_log(sql: &str, args: &[&(dyn ToSql + Sync)]) {
    let format = format!(
        "Exec   ==> {}\n{}[pgbatis] [{}] Args   ==> {:?}",
        &sql, LOG_SPACE, "", args
    );
    trace!("{}", format);
}

/// 将指定表加入逻辑删除排除名单。
///
/// 排除名单中的表在执行 [`remove`] 时将执行物理删除（`DELETE`）而非软删除（`UPDATE SET is_deleted=1`），
/// 查询时也不会自动附加 `is_deleted = 0` 条件。
///
/// # 参数
/// - `table_name`: 要排除逻辑删除的表名
///
/// # 示例
///
/// ```rust,ignore
/// // 对 log 表执行物理删除
/// pgbatis::set_unlogic_delete_table("sys_log");
/// ```
pub fn set_unlogic_delete_table(table_name: &str) {
    let mut exclusion_table_m = EXCLUSION_TABLE.lock().unwrap();
    exclusion_table_m.push(table_name.to_string());
}

/// 初始化 PostgreSQL 连接池。**必须在任何数据库操作之前调用。**
///
/// 创建 `deadpool-postgres` 连接池并存储到全局 [`DATABASE_POOL`] 中。
/// 若逻辑删除插件尚未设置，会自动以默认配置（`is_deleted` 字段，删除值=1，未删除值=0）初始化。
///
/// # 参数
/// - `host`: 数据库主机地址
/// - `port`: 数据库端口
/// - `user`: 用户名
/// - `password`: 密码
/// - `dbname`: 数据库名
/// - `max_size`: 连接池最大连接数
///
/// # 返回
/// - `Ok(())` 表示连接池初始化成功
/// - `Err(String)` 表示连接池创建失败
///
/// # 示例
///
/// ```rust,ignore
/// pgbatis::link("127.0.0.1", 5432, "myuser", "mypass", "mydb", 10).await?;
/// ```
pub async fn link(
    host: &str,
    port: u16,
    user: &str,
    password: &str,
    dbname: &str,
    max_size: usize,
) -> Result<(), String> {
    let mut pg_config = tokio_postgres::Config::new();
    //   pg_config.options(&driver_url);
    pg_config.host(host);
    pg_config.port(port);
    pg_config.user(user);
    pg_config.password(password);
    pg_config.dbname(dbname);
    let mgr_config = ManagerConfig {
        recycling_method: RecyclingMethod::Verified,
    };
    let mgr = Manager::from_config(pg_config, NoTls, mgr_config);
    //创建连接池数量
    let pool = Pool::builder(mgr).max_size(max_size).build().unwrap();
    
    let _ = DATABASE_POOL.pools.set(pool);

    // 防御式初始化：若逻辑删除插件尚未设置，则按默认配置初始化一次
    {
        let mut guard = DATABASE_POOL.logic_plugin.lock().unwrap();
        if guard.is_none() {
            let exclusion_table = {
                let list = EXCLUSION_TABLE.lock().unwrap();
                list.clone()
            };
            *guard = Some(Box::new(LogicDeletePlugin::new_opt(
                "is_deleted",
                1,
                0,
                exclusion_table,
            )));
            info!("pgbatis logic_delete plugin initialized in link() (fallback)");
        }
    }

    let driver_url = format!("postgresql://{}:{}@{}/{}", user, password, host, dbname);
    info!("数据库连接:{}", driver_url);
    //trace_exec_log(&driver_url, args);

    //DATABASE_POOL.logic_plugin.as_ref().unwrap().insert_exclusion_table("hellow");

    return Ok(());
}

/// 类型化分页查询结果。
///
/// 由 [`fetch_page`] 返回，包含当前页数据及分页元信息。
///
/// # 字段
/// - `records`: 当前页数据列表
/// - `total`: 符合条件的总记录数
/// - `pages`: 总页数
/// - `current_page`: 当前页码（从 1 开始）
/// - `page_size`: 每页记录数
#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq)]
pub struct PageT<T>
where
    T: Parameters,
{
    /// 当前页数据列表。
    pub records: Vec<T>,
    /// 符合条件的总记录数。
    pub total: u64,
    /// 总页数。
    pub pages: u64,
    /// 当前页码（从 1 开始）。
    pub current_page: u64,
    /// 每页记录数。
    pub page_size: u64,
}

/// HashMap 形式的分页查询结果。
///
/// 由 [`query_page`] 返回，适用于联表查询、统计查询等不需要定义返回结构体的场景。
///
/// # 字段
/// - `records`: 当前页数据，每行为 `HashMap<String, Value>`
/// - `total`: 符合条件的总记录数
/// - `pages`: 总页数
/// - `current_page`: 当前页码（从 1 开始）
/// - `page_size`: 每页记录数
#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq)]
pub struct PageHash {
    /// 当前页数据，每行为 `HashMap<String, Value>`。
    pub records: Vec<HashMap<String, Value>>,
    /// 符合条件的总记录数。
    pub total: u64,
    /// 总页数。
    pub pages: u64,
    /// 当前页码（从 1 开始）。
    pub current_page: u64,
    /// 每页记录数。
    pub page_size: u64,
}

/// 执行原生 SQL（INSERT / UPDATE / DELETE 等非查询语句）。
///
/// # 参数
/// - `sql`: 带 `$n` 占位符的 SQL 字符串
/// - `params`: 与占位符顺序对应的参数数组
///
/// # 返回
/// - `Ok(u64)` — 受影响的行数
/// - `Err(Error)` — 执行失败
///
/// # 示例
///
/// ```rust,ignore
/// let sql = "UPDATE users SET name = $1 WHERE id = $2".to_string();
/// let rows = pgbatis::execute(&sql, &[&"NewName", &"user_1"]).await?;
/// ```
pub async fn execute(sql: &String, params: &[&(dyn ToSql + Sync)]) -> Result<u64, Error> {
    let pools: &Pool = DATABASE_POOL.pools.get().unwrap();
    let client = pools.get().await.unwrap();
    let statement = client.prepare(sql.as_str()).await.unwrap();
    let result = client.execute(&statement, &params).await;
    match result {
        Ok(t) => {
            trace!("execute 执行成功");
            return Ok(t);
        }
        Err(e) => {
            // let err_str = format!("e:{}", e);
           
            error!("{:?}", e);
            return Err(e);
        }
    }
}

/// 保存实体到数据库（执行 INSERT 操作）。
///
/// SQL 由实体实现的 [`Parameters::gen_save`] 方法自动生成。
///
/// # 参数
/// - `p`: 要保存的实体，必须实现 [`Parameters`]（推荐通过 `#[derive(PGCRUD)]` 自动实现）
/// - `prefix`: 可选的表名前缀
/// - `suffix`: 可选的表名后缀
///
/// # 返回
/// - `Ok(u64)` — 受影响的行数
/// - `Err(Error)` — 执行失败
///
/// # 示例
///
/// ```rust,ignore
/// let user = User { id: Some("1".into()), name: Some("Alice".into()), age: None };
/// pgbatis::save(&user, None, None).await?;
/// ```
pub async fn save<T>(p: T, prefix: Option<String>, suffix: Option<String>) -> Result<u64, Error>
where
    T: Parameters,
{
    let (sql, args) = p.gen_save(prefix, suffix).unwrap();
    //跟踪日志
    trace_exec_log(&sql, &args);
    //取出  client
    let pools: &Pool = DATABASE_POOL.pools.get().unwrap();
    let client = pools.get().await.unwrap();
    let statement = client.prepare(sql.as_str()).await.unwrap();
    let result = client.execute(&statement, &args).await;
    match result {
        Ok(t) => {
            trace!("SAVE 执行成功");
            return Ok(t);
        }
        Err(e) => {
            //let err_str = format!("e:{}", e);
            error!("{:?}", e);
            return Err(e);
        }
    }
}
/// 执行 UPDATE 操作。
///
/// 根据实体生成 SET 子句，结合 [`Wrapper`] 生成 WHERE 条件。
/// 若逻辑删除插件启用且表未排除，WHERE 中会自动追加 `is_deleted = 0` 条件。
///
/// # 参数
/// - `p`: 包含要更新字段值的实体
/// - `wrapper`: WHERE 条件构造器
/// - `prefix`: 可选的表名前缀
/// - `suffix`: 可选的表名后缀
///
/// # 返回
/// - `Ok(u64)` — 受影响的行数
/// - `Err(Error)` — 执行失败
///
/// # 示例
///
/// ```rust,ignore
/// use pgbatis::Wrapper;
/// let user = User { name: Some("Bob".into()), ..Default::default() };
/// let wrapper = Wrapper::new().eq(&"id", &"user_1");
/// pgbatis::update(user, wrapper, None, None).await?;
/// ```
pub async fn update<T>(
    p: T,
    wrapper: Wrapper<'_>,
    prefix: Option<String>,
    suffix: Option<String>,
) -> Result<u64, Error>
where
    T: Parameters,
{
    //p.set_prefix(prefix);
    let (mut sql, mut args, args_number) = p.gen_update(prefix.clone(), suffix.clone()).unwrap();

    //获取逻辑删除部分的SQL
    let table_name = T::get_table_name(prefix, suffix);
    let logic_plugin_sql = get_logic_undelete(&table_name);

    let (where_sql, mut where_args) = wrapper.build(args_number).unwrap();
    if !where_sql.is_empty() && !logic_plugin_sql.is_empty() {
        sql = format!("{} WHERE {} AND {}", sql, where_sql, logic_plugin_sql);
    } else if !where_sql.is_empty() && logic_plugin_sql.is_empty() {
        sql = format!("{} WHERE {}  ", sql, where_sql);
    } else if where_sql.is_empty() && !logic_plugin_sql.is_empty() {
        sql = format!("{} WHERE {}  ", sql, logic_plugin_sql);
    }
    args.append(&mut where_args);
    //跟踪日志
    trace_exec_log(&sql, &args);
    //取出  client
    let pools: &Pool = DATABASE_POOL.pools.get().unwrap();
    let client = pools.get().await.unwrap();
    let statement = client.prepare(sql.as_str()).await.unwrap();
    let result = client.execute(&statement, &args).await;

    match result {
        Ok(t) => {
          //  info!("更新执行成功");
            return Ok(t);
        }
        Err(e) => {
            //  let err_str = format!("e:{}", e);
            error!("{:?}", e);
            return Err(e);
        }
    }
}

/// 删除操作。默认行为取决于逻辑删除插件配置：
///
/// - **逻辑删除启用且表未排除**：执行软删除（`UPDATE SET is_deleted = 1`）
/// - **逻辑删除禁用或表已排除**：执行物理删除（`DELETE FROM`）
///
/// 如需强制物理删除，请使用 [`permanent_deletion`]。
///
/// # 参数
/// - `wrapper`: WHERE 条件构造器，用于指定要删除的行
/// - `prefix`: 可选的表名前缀
/// - `suffix`: 可选的表名后缀
///
/// # 返回
/// - `Ok(u64)` — 受影响的行数
/// - `Err(Error)` — 执行失败
///
/// # 示例
///
/// ```rust,ignore
/// use pgbatis::Wrapper;
/// // 软删除（如果逻辑删除启用）
/// let wrapper = Wrapper::new().eq(&"id", &"user_1");
/// pgbatis::remove::<User>(wrapper, None, None).await?;
/// ```
pub async fn remove<P>(
    wrapper: Wrapper<'_>,
    prefix: Option<String>,
    suffix: Option<String>,
) -> Result<u64, Error>
where
    P: Parameters,
{
    //正常的写法  DELETE FROM tableName    WHERE
    let table_name = P::get_table_name(prefix, suffix);
    let mut sql = format!("DELETE FROM \"{}\"", &table_name);

    //判断是否有逻辑删除插件，如果有且该表未在排除列表中，则改为逻辑删除
    // 使用全局 EXCLUSION_TABLE 判断是否排除
    let is_excluded = {
        let list = EXCLUSION_TABLE.lock().unwrap();
        list.contains(&table_name)
    };
    if let Some(plugin) = DATABASE_POOL.logic_plugin.lock().unwrap().as_ref() {
        if !is_excluded {
            sql = format!(
                "UPDATE \"{}\" set \"{}\" = {} ",
                table_name,
                plugin.column(),
                plugin.deleted(),
            );
        }
    }
    debug!("remove plugin_present:{} excluded:{} sql:{}", DATABASE_POOL.logic_plugin.lock().unwrap().is_some(), is_excluded, sql);
    let (where_sql, args) = wrapper.build(1).unwrap();
    if !where_sql.is_empty() {
        sql = format!("{} where {}", sql, where_sql);
    }
    //跟踪日志
    trace_exec_log(&sql, &args);

    //取出  client
    let pools: &Pool = DATABASE_POOL.pools.get().unwrap();
    let client = pools.get().await.unwrap();
    let statement = client.prepare(sql.as_str()).await.unwrap();
    let result = client.execute(&statement, &args).await;
    match result {
        Ok(t) => {
           // info!("更新执行成功");
            return Ok(t);
        }
        Err(e) => {
            //  let err_str = format!("e:{}", e);
            error!("{:?}", e);
            return Err(e);
        }
    }
}

/// 强制物理删除（`DELETE FROM`），忽略逻辑删除插件配置。
///
/// 即使表未在逻辑删除排除名单中，也会执行真正的 SQL DELETE。
///
/// # 参数
/// - `wrapper`: WHERE 条件构造器
/// - `prefix`: 可选的表名前缀
/// - `suffix`: 可选的表名后缀
///
/// # 返回
/// - `Ok(u64)` — 受影响的行数
/// - `Err(Error)` — 执行失败
///
/// # 示例
///
/// ```rust,ignore
/// use pgbatis::Wrapper;
/// let wrapper = Wrapper::new().eq(&"id", &"user_1");
/// // 强制物理删除
/// pgbatis::permanent_deletion::<User>(wrapper, None, None).await?;
/// ```
pub async fn permanent_deletion<P>(
    wrapper: Wrapper<'_>,
    prefix: Option<String>,
    suffix: Option<String>,
) -> Result<u64, Error>
where
    P: Parameters,
{
    //正常的写法  DELETE FROM tableName    WHERE
    let table_name = P::get_table_name(prefix, suffix);
    let mut sql = format!("DELETE FROM \"{}\"", &table_name);

   // debug!("remove plugin_present:{} excluded:{} sql:{}", DATABASE_POOL.logic_plugin.lock().unwrap().is_some(), is_excluded, sql);
    let (where_sql, args) = wrapper.build(1).unwrap();
    if !where_sql.is_empty() {
        sql = format!("{} where {}", sql, where_sql);
    }
    //跟踪日志
    trace_exec_log(&sql, &args);

    //取出  client
    let pools: &Pool = DATABASE_POOL.pools.get().unwrap();
    let client = pools.get().await.unwrap();
    let statement = client.prepare(sql.as_str()).await.unwrap();
    let result = client.execute(&statement, &args).await;
    match result {
        Ok(t) => {
           // info!("更新执行成功");
            return Ok(t);
        }
        Err(e) => {
            //  let err_str = format!("e:{}", e);
            error!("{:?}", e);
            return Err(e);
        }
    }
}

/// 通过一个字段执行删除操作
// pub async fn remove_by_column<P,C,T >(column: C, value: T,prefix: Option<String>,suffix:Option<String>) -> Result<u64, Error>
// where
//     P: Parameters,
//     C: ColumnExt,
//     T: ToSql + Sync,
// {
//     //获取逻辑删除部分的SQL
//     let table_name = P::get_table_name(prefix,suffix);
//     let wrapper = Wrapper::new().eq(&column, &value);
//     remove(&table_name, wrapper).await
// }

/// 单表查询，返回实体列表（不分页）。
///
/// 根据 [`Wrapper`] 构造 WHERE、ORDER BY 条件。
/// 若逻辑删除插件启用且表未排除，自动追加 `is_deleted = 0` 过滤。
///
/// # 参数
/// - `wrapper`: 条件构造器，支持 `eq`、`like`、`set_order_by_column_ext` 等链式方法
/// - `prefix`: 可选的表名前缀
/// - `suffix`: 可选的表名后缀
///
/// # 返回
/// - `Ok(Vec<T>)` — 查询结果列表
/// - `Err(Error)` — 执行失败
///
/// # 示例
///
/// ```rust,ignore
/// use pgbatis::Wrapper;
/// let wrapper = Wrapper::new()
///     .eq(&"name", &"Alice")
///     .set_order_by_column_ext(&"id", true);
/// let users: Vec<User> = pgbatis::fetch(wrapper, None, None).await?;
/// ```
pub async fn fetch<T>(
    wrapper: Wrapper<'_>,
    prefix: Option<String>,
    suffix: Option<String>,
) -> Result<Vec<T>, Error>
where
    T: Parameters,
{
    let field_name = wrapper.clone().get_recoder_field::<T>();
    let table_name = T::get_table_name(prefix, suffix);
    // let order_by = wrapper.order_by.clone();
    //  let desc = wrapper.desc.clone();
    let (where_sql, args) = wrapper.clone().build(1).unwrap();
    //获取逻辑未删除部分的SQL
    let logic_plugin_sql = get_logic_undelete(&table_name);

    let mut sql = String::new();
    sql.push_str("SELECT ");
    sql.push_str(field_name.as_str());
    sql.push_str(" FROM ");
    sql.push_str(table_name.as_str());

    let mut had_where = false;
    // if args.len() != 0 {
    //     sql.push_str(" WHERE ");
    //     sql.push_str(where_sql.as_str());
    //     had_where = true;
    // }
    if !where_sql.is_empty() {
        sql.push_str(" WHERE ");
        sql.push_str(where_sql.as_str());
        had_where = true;
    }

    if !logic_plugin_sql.is_empty() {
        if had_where {
            sql.push_str(" AND ");
        } else {
            sql.push_str(" WHERE ");
        }
        sql.push_str(logic_plugin_sql.as_str());
    }

    // if order_by !== None{
    //     let desc_str = if desc {"desc"} else {"asc"};
    //     let order_by_format = format!("order by {} {} " ,order_by.clone(),desc_str);
    let order_by_format = match wrapper.get_order_by() {
        Some(t) => t,
        None => " ".to_string(),
    };
    sql.push_str(&order_by_format);

    //跟踪日志
    trace_exec_log(&sql, &args);
    let pools: &Pool = DATABASE_POOL.pools.get().unwrap();
    let client = pools.get().await.unwrap();
    let statement = client.prepare(sql.as_str()).await.unwrap();
    let result = client.query(&statement, &args).await?;
    //  println!("result:{:?}", result);

    let result_t = T::return_list(result);

    return Ok(result_t);
}

/// 单表查询，返回 `Vec<HashMap<String, Value>>`（不分页）。
///
/// 与 [`fetch`] 类似，但返回值是 HashMap 列表，无需预定义返回结构体。
/// 适用于字段名动态变化或只需部分字段的场景。
///
/// # 参数
/// - `wrapper`: 条件构造器，通过 `set_recoder_field` 指定返回字段
/// - `prefix`: 可选的表名前缀
/// - `suffix`: 可选的表名后缀
///
/// # 返回
/// - `Ok(Vec<HashMap<String, Value>>)` — 查询结果列表
/// - `Err(Error)` — 执行失败
pub async fn fetch_with_recoder_field<T>(
    wrapper: Wrapper<'_>,
    prefix: Option<String>,
    suffix: Option<String>,
) -> Result<Vec<HashMap<String, Value>>, Error>
where
    T: Parameters,
{
    let field_name = wrapper.clone().get_recoder_field::<T>();
    let table_name = T::get_table_name(prefix, suffix);
    // let order_by = wrapper.order_by.clone();
    //  let desc = wrapper.desc.clone();
    let (where_sql, args) = wrapper.clone().build(1).unwrap();
    //获取逻辑未删除部分的SQL
    let logic_plugin_sql = get_logic_undelete(&table_name);

    let mut sql = String::new();
    sql.push_str("SELECT ");
    sql.push_str(field_name.as_str());
    sql.push_str(" FROM ");
    sql.push_str(table_name.as_str());

    let mut had_where = false;
    // if args.len() != 0 {
    //     sql.push_str(" WHERE ");
    //     sql.push_str(where_sql.as_str());
    //     had_where = true;
    // }
    if !where_sql.is_empty() {
        sql.push_str(" WHERE ");
        sql.push_str(where_sql.as_str());
        had_where = true;
    }

    if !logic_plugin_sql.is_empty() {
        if had_where {
            sql.push_str(" AND ");
        } else {
            sql.push_str(" WHERE ");
        }
        sql.push_str(logic_plugin_sql.as_str());
    }

    // if order_by !== None{
    //     let desc_str = if desc {"desc"} else {"asc"};
    //     let order_by_format = format!("order by {} {} " ,order_by.clone(),desc_str);
    let order_by_format = match wrapper.get_order_by() {
        Some(t) => t,
        None => " ".to_string(),
    };
    sql.push_str(&order_by_format);

    //跟踪日志
    trace_exec_log(&sql, &args);
    let pools: &Pool = DATABASE_POOL.pools.get().unwrap();
    let client = pools.get().await.unwrap();
    let statement = client.prepare(sql.as_str()).await.unwrap();
    let result = client.query(&statement, &args).await?;
    //  println!("result:{:?}", result);

    // let result_t = T::return_list(result);
    let mut new_row_hashmap = Vec::new();

    for row in result {
        new_row_hashmap.push(unit::pg_value_to_json_value(&row));
    }

    return Ok(new_row_hashmap);
}

/// 单表查询单条数据。
///
/// 与 [`fetch`] 类似，但只返回第一条匹配记录。
/// 若逻辑删除插件启用且表未排除，自动追加 `is_deleted = 0` 过滤。
///
/// # 参数
/// - `wrapper`: 条件构造器
/// - `prefix`: 可选的表名前缀
/// - `suffix`: 可选的表名后缀
///
/// # 返回
/// - `Ok(T)` — 查询到的实体
/// - `Err(Error)` — 执行失败（包括未找到记录的情况）
///
/// # 示例
///
/// ```rust,ignore
/// use pgbatis::Wrapper;
/// let wrapper = Wrapper::new().eq(&"id", &"user_1");
/// let user: User = pgbatis::fetch_one(wrapper, None, None).await?;
/// ```
pub async fn fetch_one<T>(
    wrapper: Wrapper<'_>,
    prefix: Option<String>,
    suffix: Option<String>,
) -> Result<T, Error>
where
    T: Parameters,
{
    //let field_name = T::get_field_list();
    let field_name = wrapper.clone().get_recoder_field::<T>();
    let table_name = T::get_table_name(prefix, suffix);

    let (where_sql, args) = wrapper.build(1).unwrap();

    //获取逻辑未删除部分的SQL
    let logic_plugin_sql = get_logic_undelete(&table_name);

    let mut sql = String::new();
    sql.push_str("SELECT ");
    sql.push_str(field_name.as_str());
    sql.push_str(" FROM ");
    sql.push_str(table_name.as_str());

    let mut had_where = false;
    // if args.len() != 0 {
    //     sql.push_str(" WHERE ");
    //     sql.push_str(where_sql.as_str());
    //     had_where = true;
    // }
    if !where_sql.is_empty() {
        sql.push_str(" WHERE ");
        sql.push_str(where_sql.as_str());
        had_where = true;
    }

    if !logic_plugin_sql.is_empty() {
        if had_where {
            sql.push_str(" AND ");
        } else {
            sql.push_str(" WHERE ");
        }
        sql.push_str(logic_plugin_sql.as_str());
    }
    //跟踪日志
    trace_exec_log(&sql, &args);
    let pools: &Pool = DATABASE_POOL.pools.get().unwrap();
    let client = pools.get().await.unwrap();
    if client.is_closed() {}
    let statement = client.prepare(sql.as_str()).await.unwrap();
    let result = client.query_one(&statement, &args).await;
    // println!("result:{:?}", result);
    match result {
        Ok(row) => {
            let result_t = T::return_one(row);
            return Ok(result_t);
        }
        Err(e) => {
            // let error = format!("{}", e);
            return Err(e);
        }
    }
}

/// 单表分页查询。
///
/// 根据 [`Wrapper`] 中设置的分页参数（`set_pages`）返回分页结果 [`PageT<T>`]。
/// 若逻辑删除插件启用且表未排除，自动追加 `is_deleted = 0` 过滤。
///
/// # 参数
/// - `wrapper`: 条件构造器，需通过 `set_pages(page_no, page_size)` 设置分页
/// - `prefix`: 可选的表名前缀
/// - `suffix`: 可选的表名后缀
///
/// # 返回
/// - `Ok(PageT<T>)` — 分页结果，total=0 时 records 为空列表
/// - `Err(Error)` — 执行失败
///
/// # 示例
///
/// ```rust,ignore
/// use pgbatis::Wrapper;
/// let wrapper = Wrapper::new()
///     .eq(&"name", &"Alice")
///     .set_pages(1, 10)
///     .set_order_by_column_ext(&"id", false);
/// let page: PageT<User> = pgbatis::fetch_page(wrapper, None, None).await?;
/// println!("第{}页/共{}页，总{}条", page.current_page, page.pages, page.total);
/// ```
pub async fn fetch_page<T>(
    wrapper: Wrapper<'_>,
    prefix: Option<String>,
    suffix: Option<String>,
) -> Result<PageT<T>, Error>
where
    T: Parameters,
{
    // let wrapper = &wrapper;
    //验证入参数
    let (_limit_str, _limit, _page_no, page_size) = wrapper.clone().get_page_info();

    let recoder_field = wrapper.clone().get_recoder_field::<T>();
    // let field_name = T::get_field_list();
    let table_name = T::get_table_name(prefix, suffix);

    let (where_sql, args) = wrapper.clone().build(1).unwrap();

    //获取逻辑未删除部分的SQL
    let logic_plugin_sql = get_logic_undelete(&table_name);

    let mut sql = String::new();
    sql.push_str("SELECT ");
    sql.push_str(recoder_field.as_str());
    sql.push_str(" FROM ");
    sql.push_str(table_name.as_str());

    let mut had_where = false;
    // if args.len() != 0 {
    //     sql.push_str(" WHERE ");
    //     sql.push_str(where_sql.as_str());
    //     had_where = true;
    // }
    if !where_sql.is_empty() {
        sql.push_str(" WHERE ");
        sql.push_str(where_sql.as_str());
        had_where = true;
    }

    //增加逻辑删除
    if !logic_plugin_sql.is_empty() {
        if had_where {
            sql.push_str(" AND ");
        } else {
            sql.push_str(" WHERE ");
        }
        sql.push_str(logic_plugin_sql.as_str());
    }

    let re_query_page_total = query_page_total(&sql, &args).await;
    debug!("re_query_page_total: {:?}", re_query_page_total);
    let total = match re_query_page_total {
        Ok(total) => total,
        Err(err_str) => return Err(err_str),
    };
    if total == 0 {
        let result = PageT {
            // data
            records: Vec::new(),
            // total num
            total: 0,
            // pages
            pages: 0,
            // current page index
            current_page:1,
            // default 10
            page_size:10,
        };

        return Ok(result);
    }

    //增加是否排序
    match wrapper.clone().get_order_by() {
        Some(order_by) => {
            sql.push_str(order_by.as_str());
        }
        None => (),
    };

    //增加翻页
    let (limit_str, _limit, current, _size) = wrapper.clone().get_page_info();
    let mut pages = total / page_size;
    let duoyu = total % page_size;
    if duoyu > 0 {
        pages = pages + 1
    }

    sql.push_str(limit_str.as_str());

    let pools: &Pool = DATABASE_POOL.pools.get().unwrap();
    let client = pools.get().await.unwrap();
    let statement = client.prepare(sql.as_str()).await.unwrap();
    let result = client.query(&statement, &args).await;

    let result = match result {
        Ok(t) => t,
        Err(e) => {
            // let error_str = format!("{}", e);
            return Err(e);
        }
    };

    let records = T::return_list(result);

    let result = PageT {
        // data
        records,
        // total num
        total,
        // pages
        pages,
        // current page index
        current_page: current,
        // default 10
        page_size,
    };

    return Ok(result);
}

/// 执行原生 SQL 查询，返回 `Vec<HashMap<String, Value>>`。
///
/// 适用于联表查询、统计查询等需要灵活 SQL 的场景。
/// **不会自动附加逻辑删除条件**，需在 SQL 中手动处理。
///
/// # 参数
/// - `sql`: 带 `$n` 占位符的 SQL 查询语句
/// - `params`: 与占位符顺序对应的参数数组
///
/// # 返回
/// - `Ok(Vec<HashMap<String, Value>>)` — 查询结果，每行为列名到值的映射
/// - `Err(Error)` — 执行失败
///
/// # 示例
///
/// ```rust,ignore
/// let sql = "SELECT u.name, o.amount FROM users u JOIN orders o ON u.id = o.user_id WHERE u.age > $1";
/// let rows = pgbatis::query(sql, &[&18]).await?;
/// for row in rows {
///     println!("name: {:?}, amount: {:?}", row.get("name"), row.get("amount"));
/// }
/// ```
pub async fn query(
    sql: &str,
    params: &[&(dyn ToSql + Sync)],
) -> Result<Vec<HashMap<String, Value>>, Error> {
    //跟踪日志
    trace_exec_log(sql, &params);
    let pools: &Pool = DATABASE_POOL.pools.get().unwrap();
    let client = pools.get().await.unwrap();
    let statement = client.prepare(&sql).await?;
    let opt_result = client.query(&statement, params).await;
    let mut new_row_hashmap = Vec::new();
    match opt_result {
        Ok(result) => {
            for row in result {
                new_row_hashmap.push(unit::pg_value_to_json_value(&row));
            }
        }
        Err(e) => {
            return Err(e);
        }
    }
    return Ok(new_row_hashmap);
}

/// 执行原生 SQL 查询，返回类型化实体列表。
///
/// 与 [`query`] 的区别是返回值通过 [`Parameters::return_list`] 转换为实体列表，
/// 要求 SELECT 字段顺序与实体定义一致。**不会自动附加逻辑删除条件。**
///
/// # 参数
/// - `sql`: 带 `$n` 占位符的 SQL 查询语句
/// - `params`: 与占位符顺序对应的参数数组
///
/// # 返回
/// - `Ok(Vec<T>)` — 查询结果，类型化实体列表
/// - `Err(Error)` — 执行失败
pub async fn query_t<T>(sql: &str, params: &[&(dyn ToSql + Sync)]) -> Result<Vec<T>, Error>
where
    T: Parameters,
{
    //跟踪日志
    trace_exec_log(&sql, &params);
    let pools: &Pool = DATABASE_POOL.pools.get().unwrap();
    let client = pools.get().await.unwrap();
    let statement = client.prepare(&sql).await?;
    let result = client.query(&statement, params).await;

    let result = match result {
        Ok(t) => t,
        Err(e) => {
            //let error_str = format!("{}", e);
            return Err(e);
        }
    };
    let records = T::return_list(result);

    return Ok(records);
}

/// 执行原生 SQL 查询，返回单行 `HashMap<String, Value>`。
///
/// 适用于联表查询、聚合查询等只返回一条记录的场景。
/// **不会自动附加逻辑删除条件。**
///
/// # 参数
/// - `sql`: 带 `$n` 占位符的 SQL 查询语句
/// - `params`: 与占位符顺序对应的参数数组
///
/// # 返回
/// - `Ok(HashMap<String, Value>)` — 单行结果
/// - `Err(String)` — 执行失败
///
/// # 示例
///
/// ```rust,ignore
/// let sql = "SELECT count(*) as cnt FROM users WHERE age > $1";
/// let row = pgbatis::query_one(sql, &[&18]).await?;
/// ```
pub async fn query_one(
    sql: &str,
    params: &[&(dyn ToSql + Sync)],
) -> Result<HashMap<String, Value>, String> {
    trace_exec_log(&sql, &params);
    let pools: &Pool = DATABASE_POOL.pools.get().unwrap();
    let client = pools.get().await.unwrap();
    let statement = client.prepare(&sql).await.map_err(|e| e.to_string())?;
    let opt_result = client.query_one(&statement, params).await;
    // let mut new_row_hashmap = Vec::new();
    match opt_result {
        Ok(result) => {
            return Ok(unit::pg_value_to_json_value(&result));
        }
        Err(e) => {
            let err_str = format!("{}", e);
            return Err(err_str);
        }
    }
}

//查询行数
//原理就是找出第一个 from 然后截取后面的条件。前面拼接上select count(*) from ......
async fn query_page_total(sql: &str, params: &[&(dyn ToSql + Sync)]) -> Result<u64, Error> {
    // 直接包裹原SQL为子查询统计，避免字符串截取引发边界问题与 panic。
    let clean_sql = sql.trim().trim_end_matches(';');
    let total_sql = format!(
        "select count(*) as total from ({}) as pgbatis_count_tmp",
        clean_sql
    );
    //跟踪日志
    trace_exec_log(&total_sql, params);
    //执行
    let pools: &Pool = DATABASE_POOL.pools.get().unwrap();
    let client = pools.get().await.unwrap();
    let statement = client.prepare(&total_sql).await?;
    let opt_result = client.query_one(&statement, params).await;
    match opt_result {
        Ok(result) => {
            let total: i64 = result.get("total");
            return Ok(total as u64);
        }
        Err(e) => {
            // let err_str = format!("{}", e);
            return Err(e);
        }
    }
}

/// 执行原生 SQL 分页查询，返回 [`PageHash`]。
///
/// 自动包装原 SQL 为子查询计算 total，并追加 ORDER BY + LIMIT + OFFSET。
/// 适用于联表查询、统计查询等复杂场景。**不会自动附加逻辑删除条件。**
///
/// # 参数
/// - `sql`: 带 `$n` 占位符的 SQL 查询语句（不含 ORDER BY / LIMIT / OFFSET）
/// - `params`: 与占位符顺序对应的参数数组
/// - `order_by`: 排序字段名
/// - `desc`: `true` 为降序，`false` 为升序
/// - `current_page`: 当前页码（从 1 开始）
/// - `page_size`: 每页记录数
///
/// # 返回
/// - `Ok(PageHash)` — 分页结果
/// - `Err(Error)` — 执行失败
///
/// # 示例
///
/// ```rust,ignore
/// let sql = "SELECT u.name, o.amount FROM users u JOIN orders o ON u.id = o.user_id";
/// let page = pgbatis::query_page(sql, &[], "name", false, 1, 10).await?;
/// ```
pub async fn query_page(
    sql: &str,
    params: &[&(dyn ToSql + Sync)],
    order_by: &str,
    desc: bool,
    current_page: u64,
    page_size: u64,
) -> Result<PageHash, Error> {
    //验证入参
    // if page_size <= 0 {return Err("page_size 必须大于0".to_string())};

    let re_query_page_total = query_page_total(&sql, params).await;

    let total = match re_query_page_total {
        Ok(total) => total,
        Err(err_str) => return Err(err_str),
    };

    //一共多少页
    let pages = total / page_size;

    let mut new_row_hashmap = Vec::new();
    //如果等于0 就是没有数据 直接返回
    if total == 0 {
        let page_data = PageHash {
            records: new_row_hashmap,
            total: total,
            pages,
            current_page,
            page_size,
        };
        return Ok(page_data);
    }

    //生成查询语句 拼接排序，页数，每页的数据条数
    let b_order_desc = if desc { "DESC" } else { "ASC" };
    //let order_str = order.join(",");
    //LIMIT [no of rows] OFFSET [row num]
    let offset = (current_page - 1) * page_size;

    let row_sql = format!(
        "{} ORDER BY  {} {} LIMIT {} OFFSET {};",
        sql, order_by, b_order_desc, page_size, offset
    );
    trace_exec_log(&row_sql, params);
    trace_exec_log(&sql, &params);
    let pools: &Pool = DATABASE_POOL.pools.get().unwrap();
    let client = pools.get().await.unwrap();
    let statement = client.prepare(&row_sql).await?;
    let opt_result = client.query(&statement, params).await;

    match opt_result {
        Ok(result) => {
            for row in result {
                let hashmap = unit::pg_value_to_json_value(&row);
                new_row_hashmap.push(hashmap);
            }
        }
        Err(e) => {
            // let err_str = format!("{}", e);
            return Err(e);
        }
    }

    let page_data = PageHash {
        records: new_row_hashmap,
        total: total,
        pages,
        current_page,
        page_size,
    };
    // return Ok(new_row_hashmap);
    Ok(page_data)
}

/// 检查表中是否存在满足列值条件的记录。
///
/// 若逻辑删除插件启用且表未排除，自动追加 `is_deleted = 0` 条件。
///
/// # 参数
/// - `table_name`: 表名
/// - `column`: 列标识，实现了 [`ColumnExt`]
/// - `value`: 列值
///
/// # 返回
/// - `Ok(true)` — 存在至少一条记录
/// - `Ok(false)` — 不存在
/// - `Err(Error)` — 执行失败
///
/// # 示例
///
/// ```rust,ignore
/// struct NameCol;
/// impl ColumnExt for NameCol { fn get(&self) -> &'static str { "name" } }
/// let exists = pgbatis::check_row_by_column("users", &NameCol, "Alice").await?;
/// ```
pub async fn check_row_by_column<C, T>(
    table_name: &str,
    column: &C,
    value: T,
) -> Result<bool, Error>
where
    C: ColumnExt,
    T: ToSql + Sync,
{
    let column_name = column.get();
    let mut sql = format!(
        "SELECT \"{}\" FROM \"{}\" WHERE \"{}\" = $1",
        column_name, table_name, column_name
    );

    //获取逻辑未删除部分的SQL
    let logic_plugin_sql = get_logic_undelete(&table_name);

    if !logic_plugin_sql.is_empty() {
        sql.push_str(" AND ");
        sql.push_str(logic_plugin_sql.as_str());
    }
    debug!("check_row_by_column sql :{}", sql);
    let pools: &Pool = DATABASE_POOL.pools.get().unwrap();
    let client = pools.get().await.unwrap();
    // let result = client.query_opt(sql.as_str(), &[&value]).await;
    // match result {
    //     Ok(opt_row) => match opt_row {
    //         Some(_row) => return Ok(true),
    //         None => return Ok(false),
    //     },
    //     Err(e) => {
    //        // let err_str = format!("{}", e);
    //         error!("check_row_by_column:{}",e);
    //         return Err(e);
    //     }
    // }
    let result = client.query(sql.as_str(), &[&value]).await;
    match result {
        Ok(opt_row) => {
            if opt_row.len() > 0 {
                return Ok(true);
            } else {
                return Ok(false);
            }
        }
        Err(e) => {
            // let err_str = format!("{}", e);
            error!("check_row_by_column:{}", e);
            return Err(e);
        }
    }
}

/// 检查表中是否存在满足 [`Wrapper`] 条件的记录。
///
/// 若逻辑删除插件启用且表未排除，自动追加 `is_deleted = 0` 条件。
///
/// # 参数
/// - `wrapper`: 条件构造器
/// - `prefix`: 可选的表名前缀
/// - `suffix`: 可选的表名后缀
///
/// # 返回
/// - `Ok(true)` — 存在至少一条记录
/// - `Ok(false)` — 不存在
/// - `Err(Error)` — 执行失败
///
/// # 示例
///
/// ```rust,ignore
/// use pgbatis::Wrapper;
/// let wrapper = Wrapper::new().eq(&"name", &"Alice");
/// let exists = pgbatis::check_row_wrap::<User>(wrapper, None, None).await?;
/// ```
pub async fn check_row_wrap<T>(
    wrapper: Wrapper<'_>,
    prefix: Option<String>,
    suffix: Option<String>,
) -> Result<bool, Error>
where
    T: Parameters,
{
    let table_name = T::get_table_name(prefix, suffix);
    let (where_sql, args) = wrapper.clone().build(1).unwrap();

    //获取逻辑未删除部分的SQL
    let logic_plugin_sql = get_logic_undelete(&table_name);

    let mut sql = String::new();
    sql.push_str("SELECT ");
    sql.push_str(" 1 ");
    sql.push_str(" FROM ");
    sql.push_str(table_name.as_str());

    let mut had_where = false;
    if args.len() != 0 {
        sql.push_str(" WHERE ");
        sql.push_str(where_sql.as_str());
        had_where = true;
    }

    //增加逻辑删除
    if !logic_plugin_sql.is_empty() {
        if had_where {
            sql.push_str(" AND ");
        } else {
            sql.push_str(" WHERE ");
        }
        sql.push_str(logic_plugin_sql.as_str());
    }
    let pools: &Pool = DATABASE_POOL.pools.get().unwrap();
    let client = pools.get().await.unwrap();
    let statement = client.prepare(sql.as_str()).await.unwrap();
    let result = client.query(&statement, &args).await;
    match result {
        Ok(opt_row) => {
            if opt_row.len() == 0 {
                return Ok(false);
            } else {
                return Ok(true);
            }
            // Some(_row) => return Ok(true),
            // None => return Ok(false),
        }
        Err(e) => {
            // let err_str = format!("{}", e);
            return Err(e);
        }
    }
}

fn get_logic_undelete(table_name: &str) -> String {
    // 使用全局 EXCLUSION_TABLE 判断是否排除
    let is_excluded = {
        let list = EXCLUSION_TABLE.lock().unwrap();
        list.iter().any(|t| t == table_name)
    };
    let guard = DATABASE_POOL.logic_plugin.lock().unwrap();
    if let Some(plugin) = guard.as_ref() {
        if !is_excluded {
            format!(
                " \"{}\" = {} ",
                plugin.column(),
                plugin.un_deleted(),
            )
        } else {
            EMPTY_STRING.to_string()
        }
    } else {
        EMPTY_STRING.to_string()
    }
}
/// 为 LIKE 查询格式化字符串：左右各加 `%`。
///
/// 例如 `"hello"` → `Some("%hello%")`，`None` → `None`。
pub fn format_like(obj: &Option<String>) -> Option<String> {
    match obj {
        Some(t) => {
            let two = format!("%{}%", t);
            Some(two)
        }
        None => None,
    }
}
/// 为 LIKE 查询格式化字符串：左侧加 `%`（后缀匹配）。
///
/// 例如 `"hello"` → `Some("%hello")`，`None` → `None`。
pub fn format_like_left(obj: &Option<String>) -> Option<String> {
    match obj {
        Some(t) => {
            let two = format!("%{}", t);
            Some(two)
        }
        None => None,
    }
}
/// 为 LIKE 查询格式化字符串：右侧加 `%`（前缀匹配）。
///
/// 例如 `"hello"` → `Some("hello%")`，`None` → `None`。
pub fn format_like_right(obj: &Option<String>) -> Option<String> {
    match obj {
        Some(t) => {
            let two = format!("{}%", t);
            Some(two)
        }
        None => None,
    }
}

/// 事务操作：先按指定列值删除，再批量插入新数据。
///
/// 先执行 `DELETE FROM {table} WHERE {column} = $1`，然后逐条 INSERT 新数据。
/// 任一步骤失败会自动回滚。
///
/// # 参数
/// - `delete_column`: 删除条件列标识
/// - `delete_value`: 删除条件值
/// - `p`: 要批量插入的实体列表
/// - `prefix`: 可选的表名前缀
/// - `suffix`: 可选的表名后缀
///
/// # 返回
/// - `Ok(0)` — 事务提交成功
/// - `Err(Error)` — 事务失败（已自动回滚）
///
/// # 注意
/// 此函数执行的是物理删除（`DELETE`），不受逻辑删除插件影响。
pub async fn transaction_delete_and_save<T,C,V>(
    delete_column: &C,
    delete_value: &V, 
    p: Vec<T>,
    prefix: Option<String>,
    suffix: Option<String>,
) -> Result<u64, Error>
where
    T: Parameters,
    V: ToSql + Sync,
    C: ColumnExt,
{
    let pools: &Pool = DATABASE_POOL.pools.get().unwrap();
    let mut client = pools.get().await.unwrap();
    let transaction = client.transaction().await.unwrap();
    let column_name = delete_column.get();
    let table_name = T::get_table_name(prefix.clone(), suffix.clone());
    let sql = format!(
        "DELETE FROM \"{}\" where \"{}\" = $1",
        &table_name, column_name
    );
    //执行删除
    let statement = transaction.prepare(sql.as_str()).await.unwrap();
    match transaction.execute(&statement, &[delete_value]).await {
        Ok(_) => {
            debug!("删除执行成功");
        }
        Err(e) => {
            error!("删除执行失败: {}", e);
            transaction.rollback().await.unwrap();
            return Err(e);
        }
    }

    for item in p.iter() {
        let (sql, params) = item.gen_save(prefix.clone(), suffix.clone()).unwrap();
        let statement = match transaction.prepare(sql.as_str()).await {
            Ok(s) => s,
            Err(e) => {
                transaction.rollback().await.unwrap();
                error!("prepare 执行失败: {}", e);
                return Err(e);
            }
        };
        let result = transaction.execute(&statement, &params).await;
        match result {
            Ok(_t) => {
                trace!("SAVE 执行成功");
                //return Ok(t);
            }
            Err(e) => {
                transaction.rollback().await.unwrap();
                error!("{:?}", e);
                return Err(e);
            }
        }
    }
    let result = transaction.commit().await;

    if result.is_err() {
        error!(" transaction.commit() 执行 提交失败！");
        //transaction.rollback().await.unwrap();
    }
    return Ok(0);
}

/// 事务批量操作的参数。
///
/// 每条参数对应一个 SQL 语句及其参数。
///
/// # 字段
/// - `statement_sql`: 带 `$n` 占位符的 SQL 语句
/// - `params`: 参数数组
#[derive(Clone, Debug)]
pub struct TransactionBatchParam<'a> {
    /// 带 `$n` 占位符的 SQL 语句。
    pub statement_sql: &'a str,
    /// 与 SQL 占位符顺序对应的参数数组。
    pub params: Vec<&'a (dyn ToSql + Sync)>,
}

/// 事务批量操作：在同一个事务中执行多条 SQL（可跨表）。
///
/// 适用于需要原子性执行多个更新/插入的场景。
/// 任一条 SQL 执行失败会自动回滚。
/// 注意：若某条非 DELETE 语句影响 0 行，也会触发回滚。
///
/// # 参数
/// - `param`: 批量操作参数列表
///
/// # 返回
/// - `Ok(0)` — 事务提交成功
/// - `Err(String)` — 事务失败（已自动回滚）
///
/// # 示例
///
/// ```rust,ignore
/// use pgbatis::TransactionBatchParam;
/// let params = vec![
///     TransactionBatchParam { statement_sql: "UPDATE users SET name = $1 WHERE id = $2", params: vec![&"Bob", &"1"] },
///     TransactionBatchParam { statement_sql: "INSERT INTO logs (msg) VALUES ($1)", params: vec![&"done"] },
/// ];
/// pgbatis::transaction_batch(params).await?;
/// ```
pub async fn transaction_batch(param: Vec<TransactionBatchParam<'_>>) -> Result<u64, String> {
    let pools: &Pool = DATABASE_POOL.pools.get().unwrap();
    let mut client = pools.get().await.unwrap();
    let transaction = client.transaction().await.unwrap();
    //  transaction.execute(statement, params);
    for item in param.iter() {
        let statement = transaction
            .prepare(item.statement_sql)
            .await
            .map_err(|e| e.to_string())?;
        match transaction.execute(&statement, &item.params).await {
            Ok(t) => {
                //如果执行没有相应任何一行，表示执行的SQL 没有意义 直接回滚??
                if t == 0 {
                    if !item.statement_sql.find("DELETE").is_some(){
                        transaction.rollback().await.unwrap();
                        error!("执行的SQL没有任何意义,响应行数为0");
                        return Err("执行的SQL没有任何意义,响应行数为0".to_string());
                    }
                }
            }
            Err(e) => {
                //执行回滚
                transaction.rollback().await.unwrap();
                error!("{:?}", e);
                return Err(e.to_string());
            }
        }
    }
    let result = transaction.commit().await;

    if result.is_err() {
        error!(" transaction.commit() 执行 提交失败！");
        //transaction.rollback().await.unwrap();
    }

    return Ok(0);
}


/// 数据库连接探活。
///
/// 执行 `SELECT 1` 验证连接池是否可用。
///
/// # 返回
/// - `Ok(())` — 连接正常
/// - `Err(String)` — 连接失败
///
/// # 示例
///
/// ```rust,ignore
/// pgbatis::ping().await.map_err(|e| format!("db down: {}", e))?;
/// ```
pub async fn ping() -> Result<(), String> {
    let pools: &Pool = DATABASE_POOL.pools.get().unwrap();
    let client = pools.get().await.unwrap();
    match client.simple_query("SELECT 1").await {
        Ok(_) => Ok(()),
        Err(e) => Err(format!("ping error: {}", e)),
    }
}