Struct Database 

pub struct Database { /* private fields */ }

A database wrapper

Contains (potentially) separate connections for readonly database instances and read/write instances.

This allows you to benefit from multi node database clusters which provide a read-only endpoint.

By if not readonly endpoint is configured the read-write endpoint is used instead.

Implementations

impl Database

pub fn ro(&self) -> &PgPool

pub fn rw(&self) -> &PgPool

Trait Implementations

impl Clone for Database

fn clone(&self) -> Database

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Database

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

Formats the value using the given formatter.

impl From<Pool<Postgres>> for Database

fn from(value: PgPool) -> Self

Converts to this type from the input type.

impl FromRef<DefaultState> for Database

fn from_ref(state: &DefaultState) -> Self

Converts to this type from a reference to the input type.

impl ProvideState<Database> for DefaultState

fn provide(&self) -> Database

impl ProvideState<Database> for PgPool

fn provide(&self) -> Database

impl ProvideStateRef<Database> for DefaultState

fn provide_ref(&self) -> &Database

fn provide_mut(&mut self) -> &mut Database

impl TryFromModule for Database

async fn try_from_module(module: &Module) -> Result<Option<Self>>

where Self: Sized,

Builds the Database module from a Module configuration item. It requires the values outlined in the DatabaseConfig struct. Requires the module name to be “database”.

use quokka::{state::Database, config::{Module, TryFromModule}};

#[tokio::main]
async fn main() {
let module = Module {
    module: "database".to_string(),
    config: toml::Value::Table(toml::toml! {
        url = "postgres://database.fail"
    })
};

assert!(Database::try_from_module(&module).await.unwrap().is_some());

let module = Module {
    module: "not_database".to_string(),
    config: toml::Value::String(String::new())
};

assert!(Database::try_from_module(&module).await.unwrap().is_none()); // Return [Option::None] as the module is not responsible for the database configuration

let module = Module {
    module: "database".to_string(),
    config: toml::Value::String(String::new())
};

assert_eq!(Database::try_from_module(&module).await.unwrap_err().status_code, 500); // Failes because the configuration format is not matched
}

fn try_from_config(config: &Config) -> impl Future<Output = Result<Self>>

where Self: Sized,

Simplifies building from the root config struct

fn try_from_modules(modules: &Vec<Module>) -> impl Future<Output = Result<Self>>

where Self: Sized,

Simplifies building from multiple modules