Struct elephantry::connection::Connection

pub struct Connection { /* private fields */ }

A connection to a database.

Implementations

impl Connection

pub fn new(dsn: &str) -> Result<Self>

pub fn async(&self) -> Async<'_>

pub fn transaction(&self) -> Transaction<'_>

Examples found in repository

examples/10-transaction.rs (line 21)

        pub fn new_employee(
            &self,
            employee: &Entity,
            department: &str,
        ) -> elephantry::Result<Entity> {
            let transaction = self.connection.transaction();

            transaction.start()?;
            transaction.set_deferrable(
                Some(vec!["employee_department_id_fkey"]),
                elephantry::transaction::Constraints::Deferred,
            )?;

            let mut employee = self.connection.insert_one::<Self>(employee)?;
            let department = self
                .connection
                .find_where::<super::department::Model>("name = $*", &[&department], None)?
                .nth(0)
                .unwrap();
            employee.department_id = department.department_id;

            let employee = self
                .connection
                .update_one::<Self>(
                    &elephantry::pk! { employee_id => employee.employee_id },
                    &employee,
                )?
                .unwrap();

            transaction.commit()?;

            Ok(employee)
        }

pub fn from_config(config: &Config) -> Result<Self>

Creates a new connection from Config.

pub fn model<M>(&self) -> M

where M: Model,

Examples found in repository

examples/06-complex.rs (line 34)

fn main() -> elephantry::Result {
    env_logger::init();

    let database_url =
        std::env::var("DATABASE_URL").unwrap_or_else(|_| "postgres://localhost".to_string());
    let elephantry = elephantry::Pool::new(&database_url)?;
    elephantry.execute(include_str!("structure.sql"))?;

    let model = elephantry.model::<employee::Model>();
    let managers_salary = model.managers_salary()?;

    dbg!(managers_salary);

    Ok(())
}

examples/07-relations.rs (line 75)

fn main() -> elephantry::Result {
    env_logger::init();

    let database_url =
        std::env::var("DATABASE_URL").unwrap_or_else(|_| "postgres://localhost".to_string());
    let elephantry = elephantry::Pool::new(&database_url)?;
    elephantry.execute(include_str!("structure.sql"))?;

    let employee_with_department = elephantry
        .model::<employee::Model>()
        .employee_with_department(1)?;
    dbg!(employee_with_department);

    Ok(())
}

examples/08-composite.rs (line 64)

fn main() -> elephantry::Result {
    env_logger::init();

    let database_url =
        std::env::var("DATABASE_URL").unwrap_or_else(|_| "postgres://localhost".to_string());
    let elephantry = elephantry::Pool::new(&database_url)?;
    elephantry.execute(include_str!("structure.sql"))?;

    let employee_with_department = elephantry
        .model::<employee::Model>()
        .employee_with_department(1)?;
    dbg!(employee_with_department);

    Ok(())
}

examples/10-transaction.rs (line 71)

fn main() -> elephantry::Result {
    env_logger::init();

    let database_url =
        std::env::var("DATABASE_URL").unwrap_or_else(|_| "postgres://localhost".to_string());
    let elephantry = elephantry::Pool::new(&database_url)?;
    elephantry.execute(include_str!("structure.sql"))?;

    let employee = elephantry.model::<employee::Model>().new_employee(
        &employee::Entity {
            employee_id: None,
            first_name: "First name".to_string(),
            last_name: "Last name".to_string(),
            birth_date: chrono::NaiveDate::from_ymd_opt(1990, 1, 1).unwrap(),
            is_manager: true,
            day_salary: 1_000.into(),
            department_id: -1,
        },
        "Direction",
    )?;

    dbg!(employee);

    Ok(())
}

pub fn execute(&self, query: &str) -> Result<Result>

Executes a simple text query, without parameter.

Examples found in repository

examples/06-complex.rs (line 19)

        pub fn managers_salary(&self) -> elephantry::Result<f32> {
            let query = "select sum(day_salary) from employee where is_manager";

            let result = self.connection.execute(query)?.get(0).get("sum");

            Ok(result)
        }
    }
}

fn main() -> elephantry::Result {
    env_logger::init();

    let database_url =
        std::env::var("DATABASE_URL").unwrap_or_else(|_| "postgres://localhost".to_string());
    let elephantry = elephantry::Pool::new(&database_url)?;
    elephantry.execute(include_str!("structure.sql"))?;

    let model = elephantry.model::<employee::Model>();
    let managers_salary = model.managers_salary()?;

    dbg!(managers_salary);

    Ok(())
}

examples/04-write.rs (line 22)

fn main() -> elephantry::Result {
    env_logger::init();

    let database_url =
        std::env::var("DATABASE_URL").unwrap_or_else(|_| "postgres://localhost".to_string());
    let elephantry = elephantry::Pool::new(&database_url)?;
    elephantry.execute(include_str!("structure.sql"))?;

    let entity = insert(&elephantry)?;
    update(&elephantry, &entity)?;
    delete(&elephantry, &entity)?;

    Ok(())
}

examples/03-read.rs (line 22)

fn main() -> elephantry::Result {
    env_logger::init();

    let database_url =
        std::env::var("DATABASE_URL").unwrap_or_else(|_| "postgres://localhost".to_string());
    let elephantry = elephantry::Pool::new(&database_url)?;
    elephantry.execute(include_str!("structure.sql"))?;

    find_by_pk(&elephantry)?;
    find_all(&elephantry)?;
    find_where(&elephantry)?;
    count_where(&elephantry)?;
    exist_where(&elephantry)?;

    Ok(())
}

examples/05-extra.rs (line 24)

fn main() -> elephantry::Result {
    env_logger::init();

    let database_url =
        std::env::var("DATABASE_URL").unwrap_or_else(|_| "postgres://localhost".to_string());
    let elephantry = elephantry::Pool::new(&database_url)?;
    elephantry.execute(include_str!("structure.sql"))?;

    let employees = elephantry.find_all::<employee::Model>(Some("order by age desc"))?;

    for employee in employees {
        dbg!(employee);
    }

    Ok(())
}

examples/07-relations.rs (line 72)

fn main() -> elephantry::Result {
    env_logger::init();

    let database_url =
        std::env::var("DATABASE_URL").unwrap_or_else(|_| "postgres://localhost".to_string());
    let elephantry = elephantry::Pool::new(&database_url)?;
    elephantry.execute(include_str!("structure.sql"))?;

    let employee_with_department = elephantry
        .model::<employee::Model>()
        .employee_with_department(1)?;
    dbg!(employee_with_department);

    Ok(())
}

examples/08-composite.rs (line 61)

fn main() -> elephantry::Result {
    env_logger::init();

    let database_url =
        std::env::var("DATABASE_URL").unwrap_or_else(|_| "postgres://localhost".to_string());
    let elephantry = elephantry::Pool::new(&database_url)?;
    elephantry.execute(include_str!("structure.sql"))?;

    let employee_with_department = elephantry
        .model::<employee::Model>()
        .employee_with_department(1)?;
    dbg!(employee_with_department);

    Ok(())
}

Additional examples can be found in:

• examples/11-notification.rs
• examples/12-copy.rs
• examples/02-query.rs
• examples/10-transaction.rs
• examples/01-execute.rs

pub fn query<E: Entity>( &self, query: &str, params: &[&dyn ToSql] ) -> Result<Rows<E>>

Executes a simple query, can have parameters.

Examples found in repository

examples/02-query.rs (line 20)

fn main() -> elephantry::Result {
    let database_url =
        std::env::var("DATABASE_URL").unwrap_or_else(|_| "postgres://localhost".to_string());
    let elephantry = elephantry::Pool::new(&database_url)?;
    elephantry.execute(include_str!("structure.sql"))?;

    let employees = elephantry.query::<employee::Entity>("select * from employee", &[])?;

    for employee in employees {
        dbg!(employee);
    }

    let total_salary = elephantry
        .query_one::<bigdecimal::BigDecimal>("select sum(day_salary) from employee", &[])?;

    dbg!(total_salary);

    Ok(())
}

examples/08-composite.rs (line 50)

        pub fn employee_with_department(&self, id: i32) -> elephantry::Result<Entity> {
            use elephantry::{Model, Projectable};

            let employee_projection = Self::create_projection()
                .unset_field("department_id")
                .add_field("departments", "array_agg(depts)")
                .alias("e")
                .to_string();

            let employee = <Self as elephantry::Model>::Structure::relation();

            let sql = format!(
                r#"
with recursive
    depts (department_id, name, parent_id) as (
        select d.department_id, d.name, d.parent_id from department d join {employee} e using(department_id) where e.employee_id = $1
        union all
        select d.department_id, d.name, d.parent_id from depts parent join department d on parent.parent_id = d.department_id
    )
select {employee_projection}
    from {employee} e, depts
    where e.employee_id = $1
    group by e.employee_id
"#
            );

            Ok(self.connection.query::<Entity>(&sql, &[&id])?.get(0))
        }

examples/07-relations.rs (line 50)

        pub fn employee_with_department(&self, id: i32) -> elephantry::Result<Entity> {
            use elephantry::{Model, Projectable};

            let employee_projection = Self::create_projection()
                .unset_field("department_id")
                .add_field("departments", "array_agg(depts)")
                .alias("e")
                .to_string();

            let employee = <Self as elephantry::Model>::Structure::relation();

            let department_projection = super::department::Model::create_projection()
                .alias("d")
                .unset_field("parent")
                .to_string();

            let department = super::department::Structure::relation();

            let sql = format!(
                r#"
with recursive
    depts (department_id, name, parent_id) as (
        select {department_projection} from {department} d join {employee} e using(department_id) where e.employee_id = $1
        union all
        select {department_projection} from depts parent join {department} d on parent.parent_id = d.department_id
    )
select {employee_projection}
    from {employee} e, depts
    where e.employee_id = $1
    group by e.employee_id
"#
            );

            Ok(self.connection.query::<Entity>(&sql, &[&id])?.get(0))
        }

pub fn query_one<E: Entity>( &self, query: &str, params: &[&dyn ToSql] ) -> Result<E>

Likes query but peaks only the first result.

Examples found in repository

examples/02-query.rs (line 27)

fn main() -> elephantry::Result {
    let database_url =
        std::env::var("DATABASE_URL").unwrap_or_else(|_| "postgres://localhost".to_string());
    let elephantry = elephantry::Pool::new(&database_url)?;
    elephantry.execute(include_str!("structure.sql"))?;

    let employees = elephantry.query::<employee::Entity>("select * from employee", &[])?;

    for employee in employees {
        dbg!(employee);
    }

    let total_salary = elephantry
        .query_one::<bigdecimal::BigDecimal>("select sum(day_salary) from employee", &[])?;

    dbg!(total_salary);

    Ok(())
}

pub fn find_by_pk<M>( &self, pk: &HashMap<&str, &dyn ToSql> ) -> Result<Option<M::Entity>>

where M: Model,

Return an entity upon its primary key. If no entities are found, None is returned.

Examples found in repository

examples/03-read.rs (line 36)

fn find_by_pk(elephantry: &elephantry::Pool) -> elephantry::Result {
    println!("# Find by primary key\n");

    let employee = elephantry.find_by_pk::<employee::Model>(&elephantry::pk!(employee_id => 1))?;
    println!("{employee:?}\n");

    Ok(())
}

pub fn find_all<M>(&self, suffix: Option<&str>) -> Result<Rows<M::Entity>>

where M: Model,

Return all elements from a relation. If a suffix is given, it is append to the query. This is mainly useful for “order by” statements.

NOTE: suffix is inserted as is with NO ESCAPING. DO NOT use it to place “where” condition nor any untrusted params.

Examples found in repository

examples/03-read.rs (line 44)

fn find_all(elephantry: &elephantry::Pool) -> elephantry::Result {
    println!("# Find all\n");
    let employees = elephantry.find_all::<employee::Model>(Some("order by birth_date desc"))?;

    for employee in employees {
        println!("{} {}", employee.first_name, employee.last_name);
    }
    println!();

    Ok(())
}

examples/05-extra.rs (line 26)

fn main() -> elephantry::Result {
    env_logger::init();

    let database_url =
        std::env::var("DATABASE_URL").unwrap_or_else(|_| "postgres://localhost".to_string());
    let elephantry = elephantry::Pool::new(&database_url)?;
    elephantry.execute(include_str!("structure.sql"))?;

    let employees = elephantry.find_all::<employee::Model>(Some("order by age desc"))?;

    for employee in employees {
        dbg!(employee);
    }

    Ok(())
}

pub fn find_where<M>( &self, clause: &str, params: &[&dyn ToSql], suffix: Option<&str> ) -> Result<Rows<M::Entity>>

where M: Model,

Perform a simple select on a given condition

NOTE: suffix is inserted as is with NO ESCAPING. DO NOT use it to place “where” condition nor any untrusted params.

Examples found in repository

examples/03-read.rs (line 57)

fn find_where(elephantry: &elephantry::Pool) -> elephantry::Result {
    println!("# Find where\n");

    let managers = elephantry.find_where::<employee::Model>("is_manager = $1", &[&true], None)?;

    for manager in managers {
        println!("{} {}", manager.first_name, manager.last_name);
    }
    println!();

    Ok(())
}

examples/10-transaction.rs (line 32)

        pub fn new_employee(
            &self,
            employee: &Entity,
            department: &str,
        ) -> elephantry::Result<Entity> {
            let transaction = self.connection.transaction();

            transaction.start()?;
            transaction.set_deferrable(
                Some(vec!["employee_department_id_fkey"]),
                elephantry::transaction::Constraints::Deferred,
            )?;

            let mut employee = self.connection.insert_one::<Self>(employee)?;
            let department = self
                .connection
                .find_where::<super::department::Model>("name = $*", &[&department], None)?
                .nth(0)
                .unwrap();
            employee.department_id = department.department_id;

            let employee = self
                .connection
                .update_one::<Self>(
                    &elephantry::pk! { employee_id => employee.employee_id },
                    &employee,
                )?
                .unwrap();

            transaction.commit()?;

            Ok(employee)
        }

pub fn paginate_find_where<M>( &self, clause: &str, params: &[&dyn ToSql], max_per_page: usize, page: usize, suffix: Option<&str> ) -> Result<Pager<M::Entity>>

where M: Model,

Paginate a query.

This is done with limit/offset, read why it’s probably not a good idea to use it: https://use-the-index-luke.com/no-offset.

pub fn count_where<M>( &self, clause: &str, params: &[&dyn ToSql] ) -> Result<usize>

where M: Model,

Return the number of records matching a condition.

Examples found in repository

examples/03-read.rs (line 70)

fn count_where(elephantry: &elephantry::Pool) -> elephantry::Result {
    println!("# Count where\n");

    let n = elephantry.count_where::<employee::Model>("is_manager = $1", &[&true])?;
    println!("{n}\n");

    Ok(())
}

examples/12-copy.rs (line 42)

fn main() -> elephantry::Result {
    env_logger::init();

    let database_url =
        std::env::var("DATABASE_URL").unwrap_or_else(|_| "postgres://localhost".to_string());
    let elephantry = elephantry::Pool::new(&database_url)?;
    elephantry.execute(include_str!("structure.sql"))?;

    let employees = (15..10_000).into_iter().map(employee::Entity::new);

    elephantry.copy::<employee::Model, _>(employees)?;

    let count = elephantry.count_where::<employee::Model>("true = true", &[])?;
    dbg!(count);

    Ok(())
}

pub fn exist_where<M>( &self, clause: &str, params: &[&dyn ToSql] ) -> Result<bool>

where M: Model,

Check if rows matching the given condition do exist or not.

Examples found in repository

examples/03-read.rs (line 79)

fn exist_where(elephantry: &elephantry::Pool) -> elephantry::Result {
    println!("# Exist where\n");

    let exist = elephantry.exist_where::<employee::Model>("day_salary < $1", &[&10_000])?;
    println!("{exist}\n");

    Ok(())
}

pub fn insert_one<M>(&self, entity: &M::Entity) -> Result<M::Entity>

where M: Model,

Insert a new entity in the database.

Returns the entity with values from database (ie: default values).

Examples found in repository

examples/04-write.rs (line 42)

fn insert(elephantry: &elephantry::Pool) -> elephantry::Result<employee::Entity> {
    let employee = employee::Entity {
        employee_id: None,
        first_name: "First name".to_string(),
        last_name: "Last name".to_string(),
        birth_date: chrono::NaiveDate::from_ymd_opt(1952, 03, 21).unwrap(),
        is_manager: false,
        day_salary: 10_000.into(),
        department_id: 3,
    };

    let inserted_entity = elephantry.insert_one::<employee::Model>(&employee)?;
    dbg!(&inserted_entity);

    let upsert_nothing =
        elephantry.upsert_one::<employee::Model>(&inserted_entity, "(employee_id)", "nothing")?;
    dbg!(&upsert_nothing);

    let upsert_update = elephantry.upsert_one::<employee::Model>(
        &inserted_entity,
        "(employee_id)",
        "update set employee_id = default",
    )?;
    dbg!(&upsert_update);

    Ok(inserted_entity)
}

examples/10-transaction.rs (line 29)

        pub fn new_employee(
            &self,
            employee: &Entity,
            department: &str,
        ) -> elephantry::Result<Entity> {
            let transaction = self.connection.transaction();

            transaction.start()?;
            transaction.set_deferrable(
                Some(vec!["employee_department_id_fkey"]),
                elephantry::transaction::Constraints::Deferred,
            )?;

            let mut employee = self.connection.insert_one::<Self>(employee)?;
            let department = self
                .connection
                .find_where::<super::department::Model>("name = $*", &[&department], None)?
                .nth(0)
                .unwrap();
            employee.department_id = department.department_id;

            let employee = self
                .connection
                .update_one::<Self>(
                    &elephantry::pk! { employee_id => employee.employee_id },
                    &employee,
                )?
                .unwrap();

            transaction.commit()?;

            Ok(employee)
        }

pub fn upsert_one<M>( &self, entity: &M::Entity, target: &str, action: &str ) -> Result<Option<M::Entity>>

where M: Model,

Try to insert a new entity in the database. On constraint violation error on target you can do an alternative action action.

See ON CONFLICT clause.

Returns the entity with values from database (ie: default values).

Examples found in repository

examples/04-write.rs (line 46)

fn insert(elephantry: &elephantry::Pool) -> elephantry::Result<employee::Entity> {
    let employee = employee::Entity {
        employee_id: None,
        first_name: "First name".to_string(),
        last_name: "Last name".to_string(),
        birth_date: chrono::NaiveDate::from_ymd_opt(1952, 03, 21).unwrap(),
        is_manager: false,
        day_salary: 10_000.into(),
        department_id: 3,
    };

    let inserted_entity = elephantry.insert_one::<employee::Model>(&employee)?;
    dbg!(&inserted_entity);

    let upsert_nothing =
        elephantry.upsert_one::<employee::Model>(&inserted_entity, "(employee_id)", "nothing")?;
    dbg!(&upsert_nothing);

    let upsert_update = elephantry.upsert_one::<employee::Model>(
        &inserted_entity,
        "(employee_id)",
        "update set employee_id = default",
    )?;
    dbg!(&upsert_update);

    Ok(inserted_entity)
}

pub fn update_one<M>( &self, pk: &HashMap<&str, &dyn ToSql>, entity: &M::Entity ) -> Result<Option<M::Entity>>

where M: Model,

Update the entity.

Returns the entity with values from database.

Examples found in repository

examples/04-write.rs (lines 63-66)

fn update(elephantry: &elephantry::Pool, entity: &employee::Entity) -> elephantry::Result {
    let mut entity = entity.clone();
    entity.day_salary = 20_000.into();

    let updated_entity = elephantry.update_one::<employee::Model>(
        &elephantry::pk!(employee_id => entity.employee_id),
        &entity,
    )?;
    dbg!(updated_entity);

    let mut data = std::collections::HashMap::new();
    data.insert("is_manager".to_string(), &true as &dyn elephantry::ToSql);

    let updated_entity = elephantry.update_by_pk::<employee::Model>(
        &elephantry::pk!(employee_id => entity.employee_id),
        &data,
    )?;
    dbg!(updated_entity);

    Ok(())
}

examples/10-transaction.rs (lines 39-42)

        pub fn new_employee(
            &self,
            employee: &Entity,
            department: &str,
        ) -> elephantry::Result<Entity> {
            let transaction = self.connection.transaction();

            transaction.start()?;
            transaction.set_deferrable(
                Some(vec!["employee_department_id_fkey"]),
                elephantry::transaction::Constraints::Deferred,
            )?;

            let mut employee = self.connection.insert_one::<Self>(employee)?;
            let department = self
                .connection
                .find_where::<super::department::Model>("name = $*", &[&department], None)?
                .nth(0)
                .unwrap();
            employee.department_id = department.department_id;

            let employee = self
                .connection
                .update_one::<Self>(
                    &elephantry::pk! { employee_id => employee.employee_id },
                    &employee,
                )?
                .unwrap();

            transaction.commit()?;

            Ok(employee)
        }

pub fn update_by_pk<M>( &self, pk: &HashMap<&str, &dyn ToSql>, data: &HashMap<String, &dyn ToSql> ) -> Result<Option<M::Entity>>

where M: Model,

Update a record and fetch it with its new values. If no records match the given key, None is returned.

Examples found in repository

examples/04-write.rs (lines 72-75)

fn update(elephantry: &elephantry::Pool, entity: &employee::Entity) -> elephantry::Result {
    let mut entity = entity.clone();
    entity.day_salary = 20_000.into();

    let updated_entity = elephantry.update_one::<employee::Model>(
        &elephantry::pk!(employee_id => entity.employee_id),
        &entity,
    )?;
    dbg!(updated_entity);

    let mut data = std::collections::HashMap::new();
    data.insert("is_manager".to_string(), &true as &dyn elephantry::ToSql);

    let updated_entity = elephantry.update_by_pk::<employee::Model>(
        &elephantry::pk!(employee_id => entity.employee_id),
        &data,
    )?;
    dbg!(updated_entity);

    Ok(())
}

pub fn delete_one<M>(&self, entity: &M::Entity) -> Result<Option<M::Entity>>

where M: Model,

Delete an entity from a table.

Returns the entity fetched from the deleted record.

Examples found in repository

examples/04-write.rs (line 82)

fn delete(elephantry: &elephantry::Pool, entity: &employee::Entity) -> elephantry::Result {
    let deleted_entity = elephantry.delete_one::<employee::Model>(&entity)?;
    dbg!(deleted_entity);

    let deleted_entity = elephantry
        .delete_by_pk::<employee::Model>(&elephantry::pk!(employee_id => entity.employee_id))?;
    dbg!(deleted_entity);

    elephantry.delete_where::<employee::Model>("employee_id = $1", &[&entity.employee_id])?;

    Ok(())
}

pub fn delete_by_pk<M>( &self, pk: &HashMap<&str, &dyn ToSql> ) -> Result<Option<M::Entity>>

where M: Model,

Delete a record from its primary key. The deleted entity is returned or None if not found.

Examples found in repository

examples/04-write.rs (line 86)

fn delete(elephantry: &elephantry::Pool, entity: &employee::Entity) -> elephantry::Result {
    let deleted_entity = elephantry.delete_one::<employee::Model>(&entity)?;
    dbg!(deleted_entity);

    let deleted_entity = elephantry
        .delete_by_pk::<employee::Model>(&elephantry::pk!(employee_id => entity.employee_id))?;
    dbg!(deleted_entity);

    elephantry.delete_where::<employee::Model>("employee_id = $1", &[&entity.employee_id])?;

    Ok(())
}

pub fn delete_where<M>( &self, clause: &str, params: &[&dyn ToSql] ) -> Result<Rows<M::Entity>>

where M: Model,

Delete records by a given condition. A collection of all deleted entries is returned.

Examples found in repository

examples/04-write.rs (line 89)

fn delete(elephantry: &elephantry::Pool, entity: &employee::Entity) -> elephantry::Result {
    let deleted_entity = elephantry.delete_one::<employee::Model>(&entity)?;
    dbg!(deleted_entity);

    let deleted_entity = elephantry
        .delete_by_pk::<employee::Model>(&elephantry::pk!(employee_id => entity.employee_id))?;
    dbg!(deleted_entity);

    elephantry.delete_where::<employee::Model>("employee_id = $1", &[&entity.employee_id])?;

    Ok(())
}

pub fn has_broken(&self) -> Result<bool>

Determines if the connection is no longer usable.

pub fn notify(&self, channel: &str, data: Option<&str>) -> Result

Send a NOTIFY event to the database server. An optional data can be sent with the notification.

Examples found in repository

examples/11-notification.rs (line 10)

fn main() -> elephantry::Result {
    let database_url =
        std::env::var("DATABASE_URL").unwrap_or_else(|_| "postgres://localhost".to_string());
    let elephantry = elephantry::Pool::new(&database_url)?;
    elephantry.execute(include_str!("structure.sql"))?;

    elephantry.listen(CHANNEL_NAME)?;
    elephantry.notify(CHANNEL_NAME, Some("payload"))?;
    listen(&elephantry)?;

    elephantry.unlisten(CHANNEL_NAME)?;
    elephantry.notify(CHANNEL_NAME, Some("payload"))?;
    listen(&elephantry)?;

    Ok(())
}

pub fn listen(&self, channel: &str) -> Result

Start to listen on the given channel.

Note: when listen is issued in a transaction it is unlisten when the transaction is committed or rollback.

Examples found in repository

examples/11-notification.rs (line 9)

fn main() -> elephantry::Result {
    let database_url =
        std::env::var("DATABASE_URL").unwrap_or_else(|_| "postgres://localhost".to_string());
    let elephantry = elephantry::Pool::new(&database_url)?;
    elephantry.execute(include_str!("structure.sql"))?;

    elephantry.listen(CHANNEL_NAME)?;
    elephantry.notify(CHANNEL_NAME, Some("payload"))?;
    listen(&elephantry)?;

    elephantry.unlisten(CHANNEL_NAME)?;
    elephantry.notify(CHANNEL_NAME, Some("payload"))?;
    listen(&elephantry)?;

    Ok(())
}

pub fn unlisten(&self, channel: &str) -> Result

Stop to listen on the given channel.

Examples found in repository

examples/11-notification.rs (line 13)

fn main() -> elephantry::Result {
    let database_url =
        std::env::var("DATABASE_URL").unwrap_or_else(|_| "postgres://localhost".to_string());
    let elephantry = elephantry::Pool::new(&database_url)?;
    elephantry.execute(include_str!("structure.sql"))?;

    elephantry.listen(CHANNEL_NAME)?;
    elephantry.notify(CHANNEL_NAME, Some("payload"))?;
    listen(&elephantry)?;

    elephantry.unlisten(CHANNEL_NAME)?;
    elephantry.notify(CHANNEL_NAME, Some("payload"))?;
    listen(&elephantry)?;

    Ok(())
}

pub fn notifies(&self) -> Result<Option<Notify>>

Check if a notification is pending. If so, the payload is returned. Otherwise, None is returned.

Examples found in repository

examples/11-notification.rs (line 21)

fn listen(elephantry: &elephantry::Connection) -> elephantry::Result {
    while let Some(notify) = elephantry.notifies()? {
        dbg!(notify);
    }

    Ok(())
}

pub fn ping(&self) -> Result

Reports the status of the server.

Examples found in repository

examples/00-config.rs (line 8)

fn main() -> elephantry::Result {
    let config = config::Config::builder()
        .add_source(config::Environment::with_prefix("DATABASE"))
        .build()?;

    let elephantry = elephantry::Pool::from_config(&config.try_deserialize()?)?;

    elephantry.ping()
}

pub fn config(&self) -> Result<Config>

Retreives connection configuration.

pub fn copy<M, I>(&self, entities: I) -> Result

where I: Iterator<Item = M::Entity>, M: Model,

Bulk insert entities via COPY mode.

Examples found in repository

examples/12-copy.rs (line 40)

fn main() -> elephantry::Result {
    env_logger::init();

    let database_url =
        std::env::var("DATABASE_URL").unwrap_or_else(|_| "postgres://localhost".to_string());
    let elephantry = elephantry::Pool::new(&database_url)?;
    elephantry.execute(include_str!("structure.sql"))?;

    let employees = (15..10_000).into_iter().map(employee::Entity::new);

    elephantry.copy::<employee::Model, _>(employees)?;

    let count = elephantry.count_where::<employee::Model>("true = true", &[])?;
    dbg!(count);

    Ok(())
}

Trait Implementations

impl Clone for Connection

fn clone(&self) -> Connection

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Connection

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

Formats the value using the given formatter.

impl Poolable for Connection

Available on crate feature rocket only.

type Error = Error

The associated error type in the event that constructing the connection manager and/or the connection pool fails.

type Manager = ConnectionManager

The associated connection manager for the given connection type.

fn pool(db_name: &str, rocket: &Rocket<Build>) -> PoolResult<Self>

Creates an r2d2 connection pool for Manager::Connection, returning the pool on success.