QueryBuilder 与参数

    fn to_string<T: QueryBuilder>(&self, query_builder: T) -> String {
        let mut sql = String::with_capacity(256);
        self.build_collect_any_into(&query_builder, &mut sql);
        sql
    }
    // ...
    fn build<T: QueryBuilder>(&self, query_builder: T) -> (String, Values) {
        let (placeholder, numbered) = query_builder.placeholder();
        let mut sql = SqlWriterValues::new(placeholder, numbered);
        self.build_collect_into(query_builder, &mut sql);
        sql.into_parts()
    }

impl SqlWriter for String {
    fn push_param<T: QueryBuilder>(&mut self, value: Value, query_builder: &T) {
        query_builder.write_value(self, &value).unwrap();
    }
    // ...
}
// ...
impl SqlWriter for SqlWriterValues {
    fn push_param<T: QueryBuilder>(&mut self, value: Value, _: &T) {
        self.string.push_str(&self.placeholder);
        if self.numbered {
            self.counter += 1;
            write_int(&mut self.string, self.counter);
        }
        self.values.push(value)
    }
    // ...
}

    fn prepare_select_statement(&self, select: &SelectStatement, sql: &mut impl SqlWriter) {
        if let Some(with) = &select.with {
            self.prepare_with_clause(with, sql);
        }

        sql.write_str("SELECT ").unwrap();

        if let Some(distinct) = &select.distinct {
            self.prepare_select_distinct(distinct, sql);
            sql.write_str(" ").unwrap();
        }

        let mut selects = select.selects.iter();
        join_io!(
            selects,
            expr,
            join {
                sql.write_str(", ").unwrap();
            },
            do {
                self.prepare_select_expr(expr, sql);
            }
        );
        // ... into、FROM（每个表之后 prepare_index_hints，最后 prepare_table_sample）

        for expr in &select.join {
            sql.write_str(" ").unwrap();
            self.prepare_join_expr(expr, sql);
        }

        self.prepare_condition(&select.r#where, "WHERE", sql);
        // ... GROUP BY、HAVING、UNION、ORDER BY

        self.prepare_select_limit_offset(select, sql);

        if let Some(lock) = &select.lock {
            sql.write_str(" ").unwrap();
            self.prepare_select_lock(lock, sql);
        }
        // ... WINDOW
    }

    fn prepare_select_limit_offset(&self, select: &SelectStatement, sql: &mut impl SqlWriter) {
        if let Some(limit) = &select.limit {
            sql.write_str(" LIMIT ").unwrap();
            self.prepare_value(limit.clone(), sql);
        }

        if let Some(offset) = &select.offset {
            sql.write_str(" OFFSET ").unwrap();
            self.prepare_value(offset.clone(), sql);
        }
    }

use sea_query::{Cond, Expr, ExprTrait, Order, PostgresQueryBuilder, Query, Values};

// Which values become $N parameters and which are written into the SQL text.
fn main() {
  let q = Query::select()
    .column("id")
    .from("cake")
    .and_where(Expr::col("name").like("%choc%"))
    .and_where(Expr::col("id").is_in([1, 2]))
    .and_where(Expr::cust("price > 0"))
    .and_where(Expr::cust_with_values("price < $1", [100]))
    .and_where(Expr::col("id").is_in(Vec::<i32>::new()))
    .cond_where(Cond::any())
    .order_by("id", Order::Field(Values(vec![3.into(), 1.into()])))
    .limit(10)
    .offset(20)
    .to_owned();

  let (sql, values) = q.build(PostgresQueryBuilder);
  println!("build    : {sql}");
  println!("values   : {:?}", values.0);
  println!("to_string: {}", q.to_string(PostgresQueryBuilder));
}

build    : SELECT "id" FROM "cake" WHERE "name" LIKE $1 AND "id" IN ($2, $3) AND (price > 0) AND (price < $4) AND $5 = $6 AND FALSE ORDER BY CASE WHEN "id"=3 THEN 0 WHEN "id"=1 THEN 1 ELSE 2 END LIMIT $7 OFFSET $8
values   : [String(Some("%choc%")), Int(Some(1)), Int(Some(2)), Int(Some(100)), Int(Some(1)), Int(Some(2)), BigUnsigned(Some(10)), BigUnsigned(Some(20))]
to_string: SELECT "id" FROM "cake" WHERE "name" LIKE '%choc%' AND "id" IN (1, 2) AND (price > 0) AND (price < 100) AND 1 = 2 AND FALSE ORDER BY CASE WHEN "id"=3 THEN 0 WHEN "id"=1 THEN 1 ELSE 2 END LIMIT 10 OFFSET 20

            Expr::CustomWithExpr(expr, values) => {
                let (placeholder, numbered) = self.placeholder();
                let mut tokenizer = Tokenizer::new(expr)
                    .for_query_builder(self)
                    .iter()
                    .peekable();
                let mut count = 0;
                while let Some(token) = tokenizer.next() {
                    match token {
                        Token::Punctuation(mark) if mark == placeholder => match tokenizer.peek() {
                            Some(Token::Punctuation(next_mark)) if next_mark == &placeholder => {
                                sql.write_str(next_mark).unwrap();
                                tokenizer.next();
                            }
                            Some(Token::Unquoted(tok)) if numbered => {
                                if let Ok(num) = tok.parse::<usize>() {
                                    self.prepare_expr(&values[num - 1], sql);
                                }
                                tokenizer.next();
                            }
                            _ => {
                                self.prepare_expr(&values[count], sql);
                                count += 1;
                            }
                        },
                        _ => sql.write_str(token.as_str()).unwrap(),
                    };
                }
            }

    fn prepare_iden(&self, iden: &DynIden, sql: &mut impl SqlWriter) {
        let q = self.quote();
        let qq = q.1 as char;

        sql.write_char(q.left()).unwrap();
        match &iden.0 {
            Cow::Borrowed(s) => sql.write_str(s).unwrap(),
            Cow::Owned(s) => {
                for char in s.chars() {
                    if char == qq {
                        sql.write_char(char).unwrap()
                    }
                    sql.write_char(char).unwrap()
                }
            }
        };
        sql.write_char(q.right()).unwrap();
    }

// https://www.postgresql.org/docs/current/sql-syntax-lexical.html#SQL-BACKSLASH-TABLE
impl EscapeBuilder for PostgresQueryBuilder {
    fn needs_escape(&self, s: &str) -> bool {
        s.chars().any(|c| match c {
            '\x08' | '\x0C' | '\n' | '\r' | '\t' | '\\' | '\'' | '\0' => true,
            c if c.is_ascii_control() => true,
            _ => false,
        })
    }

    fn write_escaped(&self, buffer: &mut impl Write, string: &str) {
        for c in string.chars() {
            match c {
                '\x08' => buffer.write_str(r#"\b"#),
                '\x0C' => buffer.write_str(r#"\f"#),
                '\n' => buffer.write_str(r"\n"),
                '\r' => buffer.write_str(r"\r"),
                '\t' => buffer.write_str(r"\t"),
                '\\' => buffer.write_str(r#"\\"#),
                '\'' => buffer.write_str(r#"\'"#),
                '\0' => buffer.write_str(r#"\0"#),
                c if c.is_ascii_control() => write!(buffer, "\\{:03o}", c as u32),
                _ => buffer.write_char(c),
            }
            .unwrap();
        }
    }
    // ...
}

    fn write_string_quoted(&self, string: &str, buffer: &mut impl Write) {
        if self.needs_escape(string) {
            buffer.write_str("E'").unwrap();
        } else {
            buffer.write_str("'").unwrap();
        }
        self.write_escaped(buffer, string);
        buffer.write_str("'").unwrap();
    }

use sea_orm::{ConnectionTrait, DbBackend, Statement};
use sea_query::{Alias, Expr, PostgresQueryBuilder, Query};

// What to_string() writes for awkward identifiers and strings, and whether
// Postgres reads the inlined literal back as the same string.
#[tokio::main]
async fn main() -> Result<(), sea_orm::DbErr> {
  let db = exp_seaorm_seaquery::connect(false).await?;
  let inputs = ["it's", r"C:\dir", "a\nb", "x\u{1a}y", "'; drop table t; --"];
  for s in inputs {
    let q = Query::select().expr_as(Expr::val(s), Alias::new("v\"x")).to_owned();
    let sql = q.to_string(PostgresQueryBuilder);
    let row = db.query_one_raw(Statement::from_string(DbBackend::Postgres, sql.clone())).await?;
    let back: String = row.expect("one row").try_get("", "v\"x")?;
    println!("{sql:<45} same={}", back == s);
  }
  Ok(())
}

SELECT E'it\'s' AS "v""x"                     same=true
SELECT E'C:\\dir' AS "v""x"                   same=true
SELECT E'a\nb' AS "v""x"                      same=true
SELECT E'x\032y' AS "v""x"                    same=true
SELECT E'\'; drop table t; --' AS "v""x"      same=true

use sea_orm::{ConnectionTrait, DbBackend, Statement};
use sea_query::{Alias, Expr, ExprTrait, Func, PostgresQueryBuilder, Query, Value};

// The same SelectStatement, sent once via build() ($1 + bound value) and once
// via to_string() (value inlined): what type does Postgres see?
#[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:00Z").unwrap().to_utc();
  let values: Vec<Value> = vec![
    "1".into(),
    serde_json::json!({"a": 1}).into(),
    ts.into(),
    Value::Int(None),
    f64::NAN.into(),
  ];
  for (i, v) in values.into_iter().enumerate() {
    let q = Query::select()
      .expr_as(Func::cust("pg_typeof").arg(Expr::val(v)).cast_as("text"), Alias::new("t"))
      .to_owned();
    // A comment makes each SQL text distinct, so no cached statement is reused.
    let (sql, vals) = q.build(PostgresQueryBuilder);
    let built = Statement::from_sql_and_values(DbBackend::Postgres, format!("{sql} -- {i}"), vals);
    let inlined = q.to_string(PostgresQueryBuilder);
    let a = typ(&db, built).await;
    let b = typ(&db, Statement::from_string(DbBackend::Postgres, inlined.clone())).await;
    println!("{inlined}\n    build: {a}\n    to_string: {b}");
  }
  let e = Query::select().expr(Expr::val("x").as_enum(Alias::new("my\"enum"))).to_owned();
  println!("as_enum build    : {}", e.build(PostgresQueryBuilder).0);
  println!("as_enum to_string: {}", e.to_string(PostgresQueryBuilder));
  Ok(())
}

async fn typ(db: &sea_orm::DatabaseConnection, stmt: Statement) -> String {
  match db.query_one_raw(stmt).await {
    Ok(Some(row)) => row.try_get::<String>("", "t").unwrap_or_else(|e| e.to_string()),
    Ok(None) => "no row".into(),
    Err(e) => e.to_string(),
  }
}

SELECT CAST(pg_typeof('1') AS text) AS "t"
    build: text
    to_string: unknown
SELECT CAST(pg_typeof('{"a":1}') AS text) AS "t"
    build: jsonb
    to_string: unknown
SELECT CAST(pg_typeof('2026-10-24 08:00:00.000000 +00:00') AS text) AS "t"
    build: timestamp with time zone
    to_string: unknown
SELECT CAST(pg_typeof(NULL) AS text) AS "t"
    build: integer
    to_string: unknown
SELECT CAST(pg_typeof(NaN) AS text) AS "t"
    build: double precision
    to_string: Query Error: error returned from database: column "nan" does not exist at line 3722
as_enum build    : SELECT CAST($1 AS "my"enum")
as_enum to_string: SELECT CAST('x' AS "my"enum")

$2 * $1      -> SELECT $1 * $2         [Int(Some(2)), Int(Some(3))]
? * ?        -> SELECT ? * ?           []
'$1' || $1   -> SELECT '$1' || $1      [String(Some("x"))]
$$ $1        -> SELECT $ $1            [String(Some("x"))]
cust(format!) -> ("SELECT \"id\" FROM \"t\" WHERE name = 'x' or '1'='1'", Values([]))