PoolOptions 与默认值

    pub fn new() -> Self {
        Self {
            // User-specifiable routines
            after_connect: None,
            before_acquire: None,
            after_release: None,
            test_before_acquire: true,
            // A production application will want to set a higher limit than this.
            max_connections: 10,
            min_connections: 0,
            // Logging all acquires is opt-in
            acquire_time_level: LevelFilter::Off,
            // Default to warning, because an acquire timeout will be an error
            acquire_slow_level: LevelFilter::Warn,
            // Fast enough to catch problems (e.g. a full pool); slow enough
            // to not flag typical time to add a new connection to a pool.
            acquire_slow_threshold: Duration::from_secs(2),
            acquire_timeout: Duration::from_secs(30),
            idle_timeout: Some(Duration::from_secs(10 * 60)),
            max_lifetime: Some(Duration::from_secs(30 * 60)),
            fair: true,
            parent_pool: None,
        }
    }

let o = PgPoolOptions::new();
println!("{o:?}");
println!(
  "max={} min={} acquire_timeout={:?} idle_timeout={:?} max_lifetime={:?} test_before_acquire={} slow_threshold={:?}",
  o.get_max_connections(),
  o.get_min_connections(),
  o.get_acquire_timeout(),
  o.get_idle_timeout(),
  o.get_max_lifetime(),
  o.get_test_before_acquire(),
  o.get_acquire_slow_threshold(),
);

PoolOptions { max_connections: 10, min_connections: 0, connect_timeout: 30s, max_lifetime: Some(1800s), idle_timeout: Some(600s), test_before_acquire: true }
max=10 min=0 acquire_timeout=30s idle_timeout=Some(600s) max_lifetime=Some(1800s) test_before_acquire=true slow_threshold=2s

    pub async fn connect_with(
        self,
        options: <DB::Connection as Connection>::Options,
    ) -> Result<Pool<DB>, Error> {
        // Don't take longer than `acquire_timeout` starting from when this is called.
        let deadline = Instant::now() + self.acquire_timeout;

        let inner = PoolInner::new_arc(self, options);

        if inner.options.min_connections > 0 {
            // If the idle reaper is spawned then this will race with the call from that task
            // and may not report any connection errors.
            inner.try_min_connections(deadline).await?;
        }

        // If `min_connections` is nonzero then we'll likely just pull a connection
        // from the idle queue here, but it should at least get tested first.
        let conn = inner.acquire().await?;
        inner.release(conn);

        Ok(Pool(inner))
    }

    pub fn after_connect<F>(mut self, callback: F) -> Self
    where
        // We're passing the `PoolConnectionMetadata` here mostly for future-proofing.
        // `age` and `idle_for` are obviously not useful for fresh connections.
        for<'c> F: Fn(&'c mut DB::Connection, PoolConnectionMetadata) -> BoxFuture<'c, Result<(), Error>>
            + 'static
            + Send
            + Sync,

let acquires = Arc::new(AtomicU32::new(0));
let n = acquires.clone();
let pool = PgPoolOptions::new()
  .max_connections(1)
  .after_connect(|conn, meta| Box::pin(async move {
    let pid: i32 = sqlx::query_scalar("select pg_backend_pid()").fetch_one(&mut *conn).await?;
    println!("  after_connect   pid={pid} {meta:?}");
    Ok(())
  }))
  .before_acquire(move |_conn, meta| {
    let n = n.clone();
    Box::pin(async move {
      let k = n.fetch_add(1, Ordering::SeqCst) + 1;
      // reject the connection on the 2nd checkout
      let keep = k != 2;
      println!("  before_acquire  #{k} {meta:?} -> {keep}");
      Ok(keep)
    })
  })
  .after_release(|_conn, meta| Box::pin(async move {
    println!("  after_release   {meta:?}");
    Ok(true)
  }))
  .connect_with(lab::opts("pool-cb"))
  .await?;
println!("built");

for round in 1..=3 {
  tokio::time::sleep(Duration::from_millis(200)).await;
  println!("round {round}");
  let mut conn = pool.acquire().await?;
  let pid: i32 = sqlx::query_scalar("select pg_backend_pid()").fetch_one(&mut *conn).await?;
  println!("  using pid={pid}");
  drop(conn);
}

            #[cfg(feature = "_rt-tokio")]
            inner: {
                debug_assert!(fair, "Tokio only has fair permits");
                tokio::sync::Semaphore::new(permits)
            },

let pool = PgPoolOptions::new()
  .__fair(false)
  .connect_with(lab::opts("pool-unfair"))
  .await?;
println!("built: size={}", pool.size());

thread 'main' (3157566) panicked at ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sqlx-core-0.9.0/src/pool/inner.rs:57:24:
Tokio only has fair permits
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

built: size=1

        let semaphore_capacity = if let Some(parent) = &options.parent_pool {
            assert!(options.max_connections <= parent.options().max_connections);
            assert_eq!(options.fair, parent.options().fair);
            // The child pool must steal permits from the parent
            0
        } else {
            capacity
        };

  after_connect   pid=478 PoolConnectionMetadata { age: 0ns, idle_for: 0ns }
built
round 1
  before_acquire  #1 PoolConnectionMetadata { age: 202.602917ms, idle_for: 202.599917ms } -> true
  using pid=478
  after_release   PoolConnectionMetadata { age: 202.970834ms, idle_for: 0ns }
round 2
  before_acquire  #2 PoolConnectionMetadata { age: 406.310667ms, idle_for: 203.155167ms } -> false
  after_connect   pid=479 PoolConnectionMetadata { age: 0ns, idle_for: 0ns }
  using pid=479
  after_release   PoolConnectionMetadata { age: 209.166µs, idle_for: 0ns }
round 3
  before_acquire  #3 PoolConnectionMetadata { age: 203.243208ms, idle_for: 202.875917ms } -> true
  using pid=479
  after_release   PoolConnectionMetadata { age: 203.720208ms, idle_for: 0ns }