Struct elephantry::transaction::Transaction

pub struct Transaction<'c> { /* private fields */ }

This struct is created by the Connection::transaction method.

Implementations

impl<'c> Transaction<'c>

pub fn start(&self) -> Result

Start a new transaction.

Examples found in repository

examples/10-transaction.rs (line 23)

        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 commit(&self) -> Result

Commit a transaction.

Examples found in repository

examples/10-transaction.rs (line 45)

        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 roolback(&self, name: Option<&str>) -> Result

Rollback a transaction. If a name is specified, the transaction is rollback to the given savepoint. Otherwise, the whole transaction is rollback.

pub fn set_save_point(&self, name: &str) -> Result

Set a savepoint in a transaction.

pub fn release_savepoint(&self, name: &str) -> Result

Drop a savepoint.

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

Tell if a transaction is open or not.

pub fn is_transaction_ok(&self) -> Result<Option<bool>>

In PostgreSQL, an error during a transaction cancels all the queries and rollback the transaction on commit. This method returns the current transaction’s status. If no transactions are open, it returns None.

pub fn set_deferrable( &self, keys: Option<Vec<&str>>, constraints: Constraints ) -> Result

Set given constraints to deferred/immediate in the current transaction. This applies to constraints being deferrable or deferred by default. If the keys is None, ALL keys will be set at the given state.

See http://www.postgresql.org/docs/current/sql-set-constraints.html

Examples found in repository

examples/10-transaction.rs (lines 24-27)

        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 set_isolation_level(&self, level: IsolationLevel) -> Result

Transaction isolation level tells PostgreSQL how to manage with the current transaction. The default is “READ COMMITTED”.

See http://www.postgresql.org/docs/current/sql-set-transaction.html

pub fn set_access_mode(&self, mode: AccessMode) -> Result

Transaction access modes tell PostgreSQL if transaction are able to write or read only.

See http://www.postgresql.org/docs/current/sql-set-transaction.html