Mock 与 Proxy

    /// In-memory mock connection used for testing (`mock`).
    #[cfg(feature = "mock")]
    MockDatabaseConnection(Arc<crate::MockDatabaseConnection>),

use sea_orm::{DatabaseConnection, DatabaseConnectionType};

fn need_clone<T: Clone>() {}

fn main() {
  need_clone::<DatabaseConnection>();
  let db = DatabaseConnection::default();
  match db.inner {
    DatabaseConnectionType::SqlxPostgresPoolConnection(_) => println!("postgres"),
    DatabaseConnectionType::Disconnected => println!("disconnected"),
  }
}

== 2.0.4 no mock
disconnected
== 2.0.4 mock
error[E0004]: non-exhaustive patterns: `DatabaseConnectionType::MockDatabaseConnection(_)` not covered
  --> src/bin/mock_shape.rs:8:9
   |
 8 |   match db.inner {
   |         ^^^^^^^^ pattern `DatabaseConnectionType::MockDatabaseConnection(_)` not covered
   |
note: `DatabaseConnectionType` defined here
  --> ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sea-orm-2.0.4/src/database/db_connection.rs:47:1
   |
47 | pub enum DatabaseConnectionType {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
...
66 |     MockDatabaseConnection(Arc<crate::MockDatabaseConnection>),
   |     ---------------------- not covered
   = note: the matched value is of type `DatabaseConnectionType`
...

# 注意：不用 sea-orm 的 mock feature——它会经 feature 统一全局禁用
# `DatabaseConnection: Clone`，破坏 app-core 连接池。

/// Handle a database connection depending on the backend enabled by the feature
/// flags. This creates a database pool. This will be `Clone` unless the feature
/// flag `mock` is enabled.
#[cfg_attr(not(feature = "mock"), derive(Clone))]
pub enum DatabaseConnection {

== 1.1.20 no mock
DatabaseConnection: Clone
== 1.1.20 mock
error[E0277]: the trait bound `DatabaseConnection: Clone` is not satisfied
 --> src/main.rs:6:16
  |
6 |   need_clone::<DatabaseConnection>();
  |                ^^^^^^^^^^^^^^^^^^ the trait `Clone` is not implemented for `DatabaseConnection`
  |
note: required by a bound in `need_clone`
 --> src/main.rs:3:18
  |
3 | fn need_clone<T: Clone>() {}
  |                  ^^^^^ required by this bound in `need_clone`

== cargo build -p pay-x
exit 0
== cargo test -p pay-x
error[E0308]: mismatched types
 --> core/src/lib.rs:5:3
  |
4 | pub fn pool_clone(db: &DatabaseConnection) -> DatabaseConnection {
  |                                               ------------------ expected `DatabaseConnection` because of return type
5 |   db.clone()
  |   ^^^^^^^^^^ expected `DatabaseConnection`, found `&DatabaseConnection`
  |
note: `DatabaseConnection` does not implement `Clone`, so `&DatabaseConnection` was cloned instead
 --> core/src/lib.rs:5:3
  |
5 |   db.clone()
  |   ^^
...
error: could not compile `core-x` (lib) due to 1 previous error
== cargo test -p core-x (1.1.20)
...
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

pub struct MockDatabase {
    db_backend: DbBackend,
    transaction: Option<OpenTransaction>,
    transaction_log: Vec<Transaction>,
    exec_results: Vec<Result<MockExecResult, DbErr>>,
    query_results: Vec<Result<Vec<MockRow>, DbErr>>,
}

pub struct MockDatabaseConnection {
    execute_counter: AtomicUsize,
    query_counter: AtomicUsize,
    mocker: Mutex<Box<dyn MockDatabaseTrait>>,
}

    fn query(&mut self, counter: usize, statement: Statement) -> Result<Vec<QueryResult>, DbErr> {
        if let Some(transaction) = &mut self.transaction {
            transaction.push(statement);
        } else {
            self.transaction_log.push(Transaction::one(statement));
        }
        if counter < self.query_results.len() {
            match std::mem::replace(
                &mut self.query_results[counter],
                Err(query_err("this value has been consumed already")),
            ) {
                // ...
            }
        } else {
            Err(query_err("`query_results` buffer is empty."))
        }
    }

// P
let db = MockDatabase::new(DatabaseBackend::Postgres)
  .append_query_results([
    vec![item::Model { id: 1, n: 10 }],
    vec![item::Model { id: 7, n: 70 }, item::Model { id: 8, n: 80 }],
  ])
  .append_exec_results([MockExecResult { last_insert_id: 0, rows_affected: 3 }])
  .into_connection();
let m = item::ActiveModel { n: Set(10), ..Default::default() }.insert(&db).await?;
let v = item::Entity::find().filter(item::Column::N.gt(1000)).all(&db).await?;
let r = db
  .execute_raw(Statement::from_string(DatabaseBackend::Postgres, "DELETE FROM no_such_table"))
  .await?;
let e = item::Entity::find_by_id(1).one(&db).await;
show(db.into_transaction_log()); // 每个 Transaction 一行一条语句，后面是 Values

--- P: 预置结果，按顺序取 ---
insert 返回 Model { id: 1, n: 10 }
find().filter(n > 1000).all 返回 [Model { id: 7, n: 70 }, Model { id: 8, n: 80 }]
DELETE FROM no_such_table 返回 rows_affected = 3
第三次查询 = Err(Query(Internal("`query_results` buffer is empty.")))
  Transaction 0:
    INSERT INTO "item" ("n") VALUES ($1) RETURNING "id", "n"  [Int(Some(10))]
  Transaction 1:
    SELECT "item"."id", "item"."n" FROM "item" WHERE "item"."n" > $1  [Int(Some(1000))]
  Transaction 2:
    DELETE FROM no_such_table
  Transaction 3:
    SELECT "item"."id", "item"."n" FROM "item" WHERE "item"."id" = $1 LIMIT $2  [Int(Some(1)), BigUnsigned(Some(1))]

    fn init() -> Self {
        Self {
            stmts: vec![Statement::from_string(DbBackend::Postgres, "BEGIN")],
            transaction_depth: 0,
        }
    }

    fn begin_nested(&mut self, db_backend: DbBackend) {
        self.transaction_depth += 1;
        self.push(Statement::from_string(
            db_backend,
            format!("SAVEPOINT savepoint_{}", self.transaction_depth),
        ));
    }

                    #[cfg(feature = "mock")]
                    QueryResultRow::Mock(row) => row.try_get(idx).map_err(|e| {
                        debug_print!("{:#?}", e.to_string());
                        err_null_idx_col(idx)
                    }),

// X
let db = MockDatabase::new(DatabaseBackend::Postgres)
  .append_query_results([[BTreeMap::from([("num_items", Value::BigInt(Some(3)))])]])
  .append_query_results([[BTreeMap::from([("num_items", Value::Int(Some(3)))])]])
  .append_query_results([[BTreeMap::from([("num_items", Value::String(Some("3".into())))])]])
  .into_connection();
for label in ["BigInt", "Int", "String"] {
  println!("{label}: {:?}", item::Entity::find().count(&db).await);
}

--- X: count() 读 num_items ---
BigInt: Ok(3)
Int: Err(Type("A null value was encountered while decoding \"num_items\""))
String: Err(Type("A null value was encountered while decoding \"num_items\""))
SELECT COUNT(*) AS num_items FROM (SELECT "item"."id", "item"."n" FROM "item") AS "sub_query"

#[async_trait::async_trait]
pub trait ProxyDatabaseTrait: Send + Sync + Debug {
    /// Execute a query in the [ProxyDatabase], and return the query results
    async fn query(&self, statement: Statement) -> Result<Vec<ProxyRow>, DbErr>;

    /// Execute a command in the [ProxyDatabase], and report the number of rows affected
    async fn execute(&self, statement: Statement) -> Result<ProxyExecResult, DbErr>;

    /// Begin a transaction in the [ProxyDatabase]
    async fn begin(&self) {}

    /// Commit a transaction in the [ProxyDatabase]
    async fn commit(&self) {}

    /// Rollback a transaction in the [ProxyDatabase]
    async fn rollback(&self) {}

    /// Start rollback a transaction in the [ProxyDatabase]
    fn start_rollback(&self) {}

    /// Ping the [ProxyDatabase], it should return an error if the database is not available
    async fn ping(&self) -> Result<(), DbErr> {
        Ok(())
    }
}

#[derive(Debug)]
struct Forward {
  db: DatabaseConnection,
}

#[async_trait::async_trait]
impl ProxyDatabaseTrait for Forward {
  async fn query(&self, stmt: Statement) -> Result<Vec<ProxyRow>, DbErr> {
    println!("  proxy.query   {}", stmt.sql);
    let rows = self.db.query_all_raw(stmt).await?;
    Ok(rows.iter().map(from_query_result_to_proxy_row).collect())
  }
  async fn execute(&self, stmt: Statement) -> Result<ProxyExecResult, DbErr> {
    println!("  proxy.execute {}", stmt.sql);
    Ok(self.db.execute_raw(stmt).await?.into())
  }
  async fn begin(&self) { println!("  proxy.begin()"); }
  async fn rollback(&self) { println!("  proxy.rollback()"); }
  fn start_rollback(&self) { println!("  proxy.start_rollback()"); }
}

let db = Database::connect_proxy(DbBackend::Postgres, Arc::new(Box::new(Forward { db: real })))
  .await?;
// S：insert、find_by_id
// T
let txn = db.begin().await?;
item::ActiveModel { n: Set(2), ..Default::default() }.insert(&txn).await?;
let sp = txn.begin().await?;
sp.commit().await?;
txn.rollback().await?;
let txn = db.begin().await?;
item::ActiveModel { n: Set(3), ..Default::default() }.insert(&txn).await?;
drop(txn);
// U：select interval '1 day' as d

--- S: 经 ProxyDatabase 插入、查询 ---
  proxy.query   INSERT INTO "item" ("n") VALUES ($1) RETURNING "id", "n"
insert 返回 Model { id: 1, n: 1 }
  proxy.query   SELECT "item"."id", "item"."n" FROM "item" WHERE "item"."id" = $1 LIMIT $2
find_by_id 返回 Some(Model { id: 1, n: 1 })
--- T: 事务：begin、嵌套 begin、rollback、drop ---
  proxy.begin()
  proxy.query   INSERT INTO "item" ("n") VALUES ($1) RETURNING "id", "n"
  proxy.begin()
  proxy.rollback()
  proxy.begin()
  proxy.query   INSERT INTO "item" ("n") VALUES ($1) RETURNING "id", "n"
  proxy.start_rollback()
item.n = [1, 2, 3]
--- U: 一个 ProxyRow 不认识的列类型 ---
  proxy.query   select interval '1 day' as d

thread 'tokio-rt-worker' (3854271) panicked at ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sea-orm-2.0.4/src/driver/sqlx_postgres.rs:945:30:
internal error: entered unreachable code: Unknown column type: INTERVAL
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
结果 Err(true)

--- Q: 事务、保存点、隔离级别、drop ---
  Transaction 0:
    BEGIN
    UPDATE "item" SET "n" = $1 WHERE "item"."id" = $2  [Int(Some(1)), Int(Some(1))]
    SAVEPOINT savepoint_1
    UPDATE "item" SET "n" = $1 WHERE "item"."id" = $2  [Int(Some(2)), Int(Some(1))]
    ROLLBACK TO SAVEPOINT savepoint_1
    UPDATE "item" SET "n" = $1 WHERE "item"."id" = $2  [Int(Some(3)), Int(Some(1))]
    COMMIT
  Transaction 1:
    BEGIN
    UPDATE "item" SET "n" = $1 WHERE "item"."id" = $2  [Int(Some(4)), Int(Some(1))]
    ROLLBACK