Struct PoolOpts

pub struct PoolOpts { /* private fields */ }

Connection pool options.

let pool_opts = PoolOpts::default()
    .with_constraints(PoolConstraints::new(15, 30).unwrap())
    .with_inactive_connection_ttl(Duration::from_secs(60));

Implementations

impl PoolOpts

pub fn new() -> Self

Calls Self::default.

pub fn with_constraints(self, constraints: PoolConstraints) -> Self

Creates the default PoolOpts with the given constraints.

pub fn constraints(&self) -> PoolConstraints

Returns pool constraints.

pub fn with_reset_connection(self, reset_connection: bool) -> Self

Sets whether to reset connection upon returning it to a pool (defaults to true).

Default behavior increases reliability but comes with cons:

• reset procedure removes all prepared statements, i.e. kills prepared statements cache
• connection reset is quite fast but requires additional client-server roundtrip (might also requires requthentication for older servers)

The purpose of the reset procedure is to:

• rollback any opened transactions (mysql_async is able to do this without explicit reset)
• reset transaction isolation level
• reset session variables
• delete user variables
• remove temporary tables
• remove all PREPARE statement (this action kills prepared statements cache)

So to encrease overall performance you can safely opt-out of the default behavior if you are not willing to change the session state in an unpleasant way.

It is also possible to selectively opt-in/out using Conn::reset_connection.

Connection URL

You can use reset_connection URL parameter to set this value. E.g.

let opts = Opts::from_url("mysql://localhost/db?reset_connection=false")?;
assert_eq!(opts.pool_opts().reset_connection(), false);

pub fn reset_connection(&self) -> bool

Returns the reset_connection value (see PoolOpts::with_reset_connection).

pub fn with_abs_conn_ttl(self, ttl: Option<Duration>) -> Self

Sets an absolute TTL after which a connection is removed from the pool. This may push the pool below the requested minimum pool size and is indepedent of the idle TTL. The absolute TTL is disabled by default. Fractions of seconds are ignored.

pub fn with_abs_conn_ttl_jitter(self, jitter: Option<Duration>) -> Self

Optionally, the absolute TTL can be extended by a per-connection random amount bounded by jitter. Setting abs_conn_ttl_jitter without abs_conn_ttl has no effect. Fractions of seconds are ignored.

pub fn abs_conn_ttl(&self) -> Option<Duration>

Returns the absolute TTL, if set.

pub fn abs_conn_ttl_jitter(&self) -> Option<Duration>

Returns the absolute TTL’s jitter bound, if set.

pub fn with_inactive_connection_ttl(self, ttl: Duration) -> Self

Pool will recycle inactive connection if it is outside of the lower bound of the pool and if it is idling longer than this value (defaults to DEFAULT_INACTIVE_CONNECTION_TTL).

Note that it may, actually, idle longer because of PoolOpts::ttl_check_interval.

Connection URL

You can use inactive_connection_ttl URL parameter to set this value (in seconds). E.g.

let opts = Opts::from_url("mysql://localhost/db?inactive_connection_ttl=60")?;
assert_eq!(opts.pool_opts().inactive_connection_ttl(), Duration::from_secs(60));

pub fn inactive_connection_ttl(&self) -> Duration

Returns a inactive_connection_ttl value.

pub fn with_ttl_check_interval(self, interval: Duration) -> Self

Pool will check idling connection for expiration with this interval (defaults to DEFAULT_TTL_CHECK_INTERVAL).

If interval is less than one second, then DEFAULT_TTL_CHECK_INTERVAL will be used.

Connection URL

You can use ttl_check_interval URL parameter to set this value (in seconds). E.g.

let opts = Opts::from_url("mysql://localhost/db?ttl_check_interval=60")?;
assert_eq!(opts.pool_opts().ttl_check_interval(), Duration::from_secs(60));

pub fn ttl_check_interval(&self) -> Duration

Returns a ttl_check_interval value.

Trait Implementations

impl Clone for PoolOpts

fn clone(&self) -> PoolOpts

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PoolOpts

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PoolOpts

fn default() -> Self

Returns the “default value” for a type.

impl Hash for PoolOpts

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for PoolOpts

fn eq(&self, other: &PoolOpts) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for PoolOpts

impl StructuralPartialEq for PoolOpts