绑到 sqlx

#[derive(Debug, Clone, PartialEq)]
pub struct Statement {
    /// The SQL query
    pub sql: String,
    /// The values for the SQL statement's parameters
    pub values: Option<Values>,
    /// The database backend this statement is constructed for.
    /// The SQL dialect depends on the backend. SQL strings are not portable across databases.
    pub db_backend: DbBackend,
}

pub(crate) fn sqlx_query(stmt: &Statement) -> sqlx::query::Query<'_, Postgres, SqlxValues> {
    let values = stmt
        .values
        .as_ref()
        .map_or(Values(Vec::new()), |values| values.clone());
    sqlx::query_with(sqlx::AssertSqlSafe(stmt.sql.as_str()), SqlxValues(values))
}

    pub async fn query_one(&self, stmt: Statement) -> Result<Option<QueryResult>, DbErr> {
        debug_print!("{}", stmt);

        let query = sqlx_query(&stmt);
        let mut conn = self.pool.acquire().await.map_err(sqlx_conn_acquire_err)?;
        crate::metric::metric!(self.metric_callback, &stmt, {
            match query.fetch_one(&mut *conn).await {
                Ok(row) => Ok(Some(row.into())),
                Err(err) => match err {
                    sqlx::Error::RowNotFound => Ok(None),
                    _ => Err(sqlx_error_to_query_err(err)),
                },
            }
        })
    }

use sea_orm::ConnectionTrait;
use sea_query::{Expr, ExprTrait, Query};

// One SelectStatement through ConnectionTrait::query_one, with sea-orm's
// debug-print and sqlx's statement log both switched on.
#[tokio::main]
async fn main() -> Result<(), sea_orm::DbErr> {
  tracing_subscriber::fmt()
    .with_env_filter("sqlx::query=info,sea_orm=debug")
    .without_time()
    .with_ansi(false)
    .init();
  let db = exp_seaorm_seaquery::connect(true).await?;
  db.execute_unprepared("drop table if exists cake; create table cake (id int4 primary key, name text); insert into cake values (1, 'it''s choc')").await?;
  let q = Query::select()
    .columns(["id", "name"])
    .from("cake")
    .and_where(Expr::col("name").like("%choc%"))
    .limit(1)
    .to_owned();
  let row = db.query_one(&q).await?.expect("one row");
  println!("name = {:?}", row.try_get::<String>("", "name"));
  db.execute_unprepared("drop table cake").await?;
  Ok(())
}

...
DEBUG sea_orm::driver::sqlx_postgres: SELECT "id", "name" FROM "cake" WHERE "name" LIKE '%choc%' LIMIT 1
 INFO sqlx::query: summary="SELECT \"id\", \"name\" FROM …" db.statement="\n\nSELECT \"id\", \"name\" FROM \"cake\" WHERE \"name\" LIKE $1 LIMIT $2\n" rows_affected=1 rows_returned=1 elapsed=1.66625ms elapsed_secs=0.00166625
name = Ok("it's choc")
...

#[derive(Clone, Debug, PartialEq)]
#[repr(transparent)]
pub struct SqlxValues(pub sea_query::Values);

impl sqlx::IntoArguments<sqlx::postgres::Postgres> for SqlxValues {
    fn into_arguments(self) -> sqlx::postgres::PgArguments {
        let mut args = sqlx::postgres::PgArguments::default();
        for arg in self.0.into_iter() {
            use sqlx::Arguments;
            match arg {
                Value::Bool(b) => {
                    let _ = args.add(b);
                }
                Value::TinyInt(i) => {
                    let _ = args.add(i);
                }
                // ...
                Value::TinyUnsigned(i) => {
                    let _ = args.add(i.map(|i| i as i16));
                }
                Value::SmallUnsigned(i) => {
                    let _ = args.add(i.map(|i| i as i32));
                }
                Value::Unsigned(i) => {
                    let _ = args.add(i.map(|i| i as i64));
                }
                Value::BigUnsigned(i) => {
                    let _ = args.add(i.map(|i| <i64 as TryFrom<u64>>::try_from(i).unwrap()));
                }
                // ...
                Value::String(s) => {
                    let _ = args.add(s.as_deref());
                }
                Value::Enum(e) => {
                    let value = match e {
                        OptionEnum::Some(v) => Some(v.value.into_owned()),
                        OptionEnum::None(_) => None,
                    };
                    let _ = args.add(value);
                }
                Value::Char(c) => {
                    let _ = args.add(c.map(|c| c.to_string()));
                }
                // ...
                #[cfg(feature = "with-json")]
                Value::Json(j) => {
                    let _ = args.add(j.as_deref());
                }
                // ...

                #[cfg(feature = "postgres-array")]
                Value::Array(ty, v) => match ty {
                    // ...
                    ArrayType::Int => {
                        let value: Option<Vec<i32>> = Value::Array(ty, v)
                            .expect("This Value::Array should consist of Value::Int");
                        let _ = args.add(value);
                    }
                    // ...

use sea_orm::{ConnectionTrait, DbBackend, Statement};
use sea_query::{ArrayType, Value};

// Bind each sea-query Value through sea-orm -> SqlxValues -> PgArguments and
// ask Postgres what type the parameter got.
#[tokio::main]
async fn main() -> Result<(), sea_orm::DbErr> {
  let db = exp_seaorm_seaquery::connect(false).await?;
  let ts = chrono::DateTime::parse_from_rfc3339("2026-10-24T08:00:00+08:00").unwrap();
  let cases: Vec<(&str, Value)> = vec![
    ("Int(None)", Value::Int(None)),
    ("String(None)", Value::String(None)),
    ("Bool(None)", Value::Bool(None)),
    ("TinyInt(Some(1))", Value::TinyInt(Some(1))),
    ("TinyUnsigned(Some(1))", Value::TinyUnsigned(Some(1))),
    ("Unsigned(Some(1))", Value::Unsigned(Some(1))),
    ("BigUnsigned(Some(1))", Value::BigUnsigned(Some(1))),
    ("Char(Some('a'))", Value::Char(Some('a'))),
    ("Json(None)", Value::Json(None)),
    ("ChronoDateTime", ts.naive_utc().into()),
    ("ChronoDateTimeUtc", ts.to_utc().into()),
    ("ChronoDateTimeWithTimeZone", ts.into()),
    ("Uuid(None)", Value::Uuid(None)),
    ("Array(Int, [1, 2])", Value::Array(ArrayType::Int, Some(Box::new(vec![1.into(), 2.into()])))),
    ("Array(String, None)", Value::Array(ArrayType::String, None)),
  ];
  for (i, (label, v)) in cases.into_iter().enumerate() {
    // Distinct SQL text per case: sqlx caches prepared statements by SQL text only.
    let sql = format!("select pg_typeof($1)::text as t, $1 is null as n, $1::text as v -- {i}");
    let row = db
      .query_one_raw(Statement::from_sql_and_values(DbBackend::Postgres, sql, [v]))
      .await?
      .expect("one row");
    let t: String = row.try_get("", "t")?;
    let n: bool = row.try_get("", "n")?;
    let s: Option<String> = row.try_get("", "v")?;
    println!("{label:<28} {t:<28} null={n:<5} text={s:?}");
  }
  Ok(())
}

Int(None)                    integer                      null=true  text=None
String(None)                 text                         null=true  text=None
Bool(None)                   boolean                      null=true  text=None
...
TinyUnsigned(Some(1))        smallint                     null=false text=Some("1")
Unsigned(Some(1))            bigint                       null=false text=Some("1")
BigUnsigned(Some(1))         bigint                       null=false text=Some("1")
Char(Some('a'))              text                         null=false text=Some("a")
Json(None)                   jsonb                        null=true  text=None
ChronoDateTime               timestamp without time zone  null=false text=Some("2026-10-24 00:00:00")
ChronoDateTimeUtc            timestamp with time zone     null=false text=Some("2026-10-24 00:00:00+00")
ChronoDateTimeWithTimeZone   timestamp with time zone     null=false text=Some("2026-10-24 00:00:00+00")
Uuid(None)                   uuid                         null=true  text=None
Array(Int, [1, 2])           integer[]                    null=false text=Some("{1,2}")
Array(String, None)          text[]                       null=true  text=None

let stmt = Statement::from_sql_and_values(
  DbBackend::Postgres,
  "select $1 is null and $2 is null as both_null, $3 as n",
  [Value::Int(None), Value::String(None), Value::BigInt(Some(42))],
);
let row = db.query_one_raw(stmt).await?.expect("one row");

  [conn 1] C->S Sync
  [conn 1] S->C ReadyForQuery(I)
  [conn 1] C->S Parse(sqlx_s_1, "select $1 is null and $2 is null as both_null, $3 as n", param oids [23, 25, 20]), Describe(S, sqlx_s_1), Sync
  [conn 1] S->C ParseComplete, ParameterDescription, RowDescription, ReadyForQuery(I)
  [conn 1] C->S Bind(portal unnamed, stmt sqlx_s_1; NULL(-1), NULL(-1), [8] 00 00 00 00 00 00 00 2a), Execute, Close(P, unnamed), Sync
  [conn 1] S->C BindComplete, DataRow(列长 1/8), CommandComplete("SELECT 1"), CloseComplete, ReadyForQuery(I)
  [conn 1] C->S Sync
  [conn 1] S->C ReadyForQuery(I)
both_null=Ok(true)

let v = match which.as_str() {
  "array" => Value::Array(ArrayType::Int, Some(Box::new(vec![1.into(), Value::Int(None)]))),
  "text" => Value::String(Some("{1,NULL}".into())),
  _ => Value::BigUnsigned(Some(u64::MAX)),
};
let stmt = Statement::from_sql_and_values(DbBackend::Postgres, "select ($1::text::int4[])::text as v", [v]);
let row = db.query_one_raw(stmt).await?.expect("one row");
println!("{:?}", row.try_get::<String>("", "v"));

== array
thread 'main' (3604831) panicked at ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sea-query-1.0.2/src/value.rs:970:27:
This Value::Array should consist of Value::Int: ValueTypeErr
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
== big
thread 'main' (3604863) panicked at ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sea-query-sqlx-0.9.1/src/sqlx_postgres.rs:55:83:
called `Result::unwrap()` on an `Err` value: TryFromIntError(PosOverflow)
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
== text
Ok("{1,NULL}")

use sea_orm::ConnectionTrait;
use sea_query::{Expr, ExprTrait, Query};

// The same SelectStatement shape, once with an i32 and once with an i64 value.
#[tokio::main]
async fn main() -> Result<(), sea_orm::DbErr> {
  let db = exp_seaorm_seaquery::connect(false).await?;
  db.execute_unprepared("drop table if exists item; create table item (id int8 primary key); insert into item values (1)").await?;
  let by_id = |v: sea_query::Value| Query::select().column("id").from("item").and_where(Expr::col("id").eq(v)).to_owned();
  println!("i32 first: {:?}", db.query_one(&by_id(1i32.into())).await.map(|r| r.is_some()));
  println!("then i64 : {:?}", db.query_one(&by_id(1i64.into())).await.map(|r| r.is_some()));
  db.execute_unprepared("drop table item").await?;
  Ok(())
}

i32 first: Ok(true)
then i64 : Err(Query(SqlxError(Database(PgDatabaseError { severity: Error, code: "22P03", message: "incorrect binary data format in bind parameter 1", detail: None, hint: None, position: None, where: Some("unnamed portal parameter $1"), schema: None, table: None, column: None, data_type: None, constraint: None, file: Some("pqformat.c"), line: Some(1951), routine: Some("exec_bind_message") }))))

TinyInt(Some(1))             "char"                       null=false text=Some("\u{1}")

insert SmallInt(Some(1))  -> Ok(1)
insert TinyInt(Some(1))   -> Err(Exec(SqlxError(Database(PgDatabaseError { severity: Error, code: "42804", message: "column \"x\" is of type smallint but expression is of type \"char\"", detail: None, hint: Some("You will need to rewrite or cast the expression."), position: Some(Original(30)), where: None, schema: None, table: None, column: None, data_type: None, constraint: None, file: Some("parse_target.c"), line: Some(586), routine: Some("transformAssignedExpr") }))))

let create = Schema::new(db.get_database_backend()).create_table_from_entity(tiny::Entity);
println!("{}", db.get_database_backend().build(&create));
db.execute(&create).await?;
let am = tiny::ActiveModel { id: Set(1), level: Set(1) };
println!("{:?}", tiny::Entity::insert(am).exec(&db).await.map(|r| r.last_insert_id));

CREATE TABLE "tiny_e" ( "id" integer GENERATED BY DEFAULT AS IDENTITY NOT NULL PRIMARY KEY, "level" smallint NOT NULL )
Err(Query(SqlxError(Database(PgDatabaseError { severity: Error, code: "42804", message: "column \"level\" is of type smallint but expression is of type \"char\"", detail: None, hint: Some("You will need to rewrite or cast the expression."), position: Some(Original(50)), where: None, schema: None, table: None, column: None, data_type: None, constraint: None, file: Some("parse_target.c"), line: Some(586), routine: Some("transformAssignedExpr") }))))