Struct rbatis::executor::RBatisTxExecutor

pub struct RBatisTxExecutor<'a> {
    pub conn: DBTx<'a>,
    pub rb: &'a Rbatis,
}

Fields

conn: DBTx<'a>

rb: &'a Rbatis

Implementations

impl<'a, 'b> RBatisTxExecutor<'b>

pub fn as_executor(&'a mut self) -> RbatisExecutor<'a, 'b>

impl<'a> RBatisTxExecutor<'a>

pub async fn begin(&mut self) -> Result<()>

pub async fn commit(&mut self) -> Result<()>

pub async fn rollback(&mut self) -> Result<()>

pub fn take_conn(self) -> Option<DBPoolConn<'a>>

impl<'a> RBatisTxExecutor<'a>

pub fn defer<Call>(self, callback: Call) -> RBatisTxExecutorGuard<'a> where
    Call: 'a + FnMut(Self) + Send, 

defer an func for example: tx.defer(|tx| {});

pub fn defer_async<R, F>(self, callback: F) -> RBatisTxExecutorGuard<'a> where
    R: 'a + Future<Output = ()>,
    F: 'a + Send + FnMut(RBatisTxExecutor<'a>) -> R, 

defer and use future method for example: tx.defer_async(|tx| async { tx.rollback().await; });

pub async fn fetch_page<T>(
    &self,
    sql: &str,
    args: Vec<Bson>,
    page_request: &dyn IPageRequest
) -> Result<Page<T>> where
    T: DeserializeOwned + Serialize + Send + Sync, 

Methods from Deref<Target = DBTx<'a>>

pub fn make_query(&'f self, sql: &'s str) -> Result<DBQuery<'s>, Error>

pub fn is_done(&self) -> bool

pub fn get_conn_mut(&mut self) -> Result<&mut DBPoolConn<'a>, Error>

pub async fn begin(&'_ mut self) -> Result<(), Error>

pub async fn commit(&'_ mut self) -> Result<(), Error>

pub async fn rollback(&'_ mut self) -> Result<(), Error>

pub async fn fetch<T>(&'_ mut self, sql: &'q str) -> Result<(T, usize), Error> where
    T: DeserializeOwned, 

pub async fn fetch_parperd<T>(
    &'_ mut self,
    sql: DBQuery<'q>
) -> Result<(T, usize), Error> where
    T: DeserializeOwned, 

pub async fn exec(&'_ mut self, sql: &'_ str) -> Result<DBExecResult, Error>

pub async fn exec_prepare(
    &'_ mut self,
    sql: DBQuery<'_>
) -> Result<DBExecResult, Error>

Trait Implementations

impl CRUDMut for RBatisTxExecutor<'_>

fn save_by_wrapper<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 mut self,
    table: &'life1 T,
    w: Wrapper,
    skips: &'life2 [Skip<'_>]
) -> Pin<Box<dyn Future<Output = Result<DBExecResult>> + Send + 'async_trait>> where
    T: CRUDTable,
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Send + 'async_trait, 

save by wrapper

fn save<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 mut self,
    table: &'life1 T,
    skips: &'life2 [Skip<'_>]
) -> Pin<Box<dyn Future<Output = Result<DBExecResult>> + Send + 'async_trait>> where
    T: CRUDTable,
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Send + 'async_trait, 

save one entity to database

fn save_batch<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 mut self,
    tables: &'life1 [T],
    skips: &'life2 [Skip<'_>]
) -> Pin<Box<dyn Future<Output = Result<DBExecResult>> + Send + 'async_trait>> where
    T: CRUDTable,
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Send + 'async_trait, 

save batch makes many value into only one sql. make sure your data do not too long!

fn save_batch_slice<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 mut self,
    tables: &'life1 [T],
    slice_len: usize,
    skips: &'life2 [Skip<'_>]
) -> Pin<Box<dyn Future<Output = Result<DBExecResult>> + Send + 'async_trait>> where
    T: CRUDTable,
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Send + 'async_trait, 

save batch slice makes many value into many sql. make sure your slice_len do not too long! slice_len = 0 : save all data slice_len != 0 : save data with slice_len everytime until save all data

fn remove_by_wrapper<'life0, 'async_trait, T>(
    &'life0 mut self,
    w: Wrapper
) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>> where
    T: CRUDTable,
    T: 'async_trait,
    'life0: 'async_trait,
    Self: Send + 'async_trait, 

remove database record by a wrapper

fn remove_by_column<'life0, 'life1, 'life2, 'async_trait, T, P>(
    &'life0 mut self,
    column: &'life1 str,
    value: &'life2 P
) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>> where
    T: CRUDTable,
    P: Serialize + Send + Sync,
    T: 'async_trait,
    P: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Send + 'async_trait, 

remove database record by id

fn remove_batch_by_column<'life0, 'life1, 'life2, 'async_trait, T, P>(
    &'life0 mut self,
    column: &'life1 str,
    values: &'life2 [P]
) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>> where
    T: CRUDTable,
    P: Serialize + Send + Sync,
    T: 'async_trait,
    P: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Send + 'async_trait, 

remove batch id for Example : rb.remove_batch_by_column::(&[“1”.to_string(),“2”.to_string()]).await; [rbatis] Exec ==> delete from biz_activity where id IN ( ? , ? )

fn update_by_wrapper<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 mut self,
    table: &'life1 T,
    w: Wrapper,
    skips: &'life2 [Skip<'_>]
) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>> where
    T: CRUDTable,
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Send + 'async_trait, 

update_by_wrapper skips: use &[Skip::Value(&bson::Bson::Null), Skip::Column(“id”), Skip::Column(column)] will skip id column and null value param

fn update_by_column<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 mut self,
    column: &'life1 str,
    table: &'life2 T
) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>> where
    T: CRUDTable,
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Send + 'async_trait, 

update database record by id update sql will be skip null value and id column

fn update_batch_by_column<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 mut self,
    column: &'life1 str,
    args: &'life2 [T]
) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>> where
    T: CRUDTable,
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Send + 'async_trait, 

remove batch database record by args

fn fetch_by_wrapper<'life0, 'async_trait, T>(
    &'life0 mut self,
    w: Wrapper
) -> Pin<Box<dyn Future<Output = Result<T>> + Send + 'async_trait>> where
    T: CRUDTable + DeserializeOwned,
    T: 'async_trait,
    'life0: 'async_trait,
    Self: Send + 'async_trait, 

fetch database record by a wrapper

fn fetch_count<'life0, 'async_trait, T>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>> where
    T: CRUDTable,
    T: 'async_trait,
    'life0: 'async_trait,
    Self: Send + 'async_trait, 

count database record

fn fetch_count_by_wrapper<'life0, 'async_trait, T>(
    &'life0 mut self,
    w: Wrapper
) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>> where
    T: CRUDTable,
    T: 'async_trait,
    'life0: 'async_trait,
    Self: Send + 'async_trait, 

count database record by a wrapper

fn fetch_by_column<'life0, 'life1, 'life2, 'async_trait, T, P>(
    &'life0 mut self,
    column: &'life1 str,
    value: &'life2 P
) -> Pin<Box<dyn Future<Output = Result<T>> + Send + 'async_trait>> where
    T: CRUDTable + DeserializeOwned,
    P: Serialize + Send + Sync,
    T: 'async_trait,
    P: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Send + 'async_trait, 

fetch database record by value

fn fetch_list_by_wrapper<'life0, 'async_trait, T>(
    &'life0 mut self,
    w: Wrapper
) -> Pin<Box<dyn Future<Output = Result<Vec<T>>> + Send + 'async_trait>> where
    T: CRUDTable + DeserializeOwned,
    T: 'async_trait,
    'life0: 'async_trait,
    Self: Send + 'async_trait, 

fetch database record list by a wrapper

fn fetch_list<'life0, 'async_trait, T>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Vec<T>>> + Send + 'async_trait>> where
    T: CRUDTable + DeserializeOwned,
    T: 'async_trait,
    'life0: 'async_trait,
    Self: Send + 'async_trait, 

fetch database record list for all

fn fetch_list_by_column<'life0, 'life1, 'life2, 'async_trait, T, P>(
    &'life0 mut self,
    column: &'life1 str,
    column_values: &'life2 [P]
) -> Pin<Box<dyn Future<Output = Result<Vec<T>>> + Send + 'async_trait>> where
    T: CRUDTable + DeserializeOwned,
    P: Serialize + Send + Sync,
    T: 'async_trait,
    P: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Send + 'async_trait, 

fetch database record list by a id array

fn fetch_page_by_wrapper<'life0, 'life1, 'async_trait, T>(
    &'life0 mut self,
    w: Wrapper,
    page: &'life1 dyn IPageRequest
) -> Pin<Box<dyn Future<Output = Result<Page<T>>> + Send + 'async_trait>> where
    T: CRUDTable + DeserializeOwned,
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Send + 'async_trait, 

fetch page database record list by a wrapper

fn fetch_page<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 mut self,
    sql: &'life1 str,
    args: Vec<Bson>,
    page_request: &'life2 dyn IPageRequest
) -> Pin<Box<dyn Future<Output = Result<Page<T>>> + Send + 'async_trait>> where
    T: DeserializeOwned + Serialize + Send + Sync,
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: Send + 'async_trait, 

fetch page result(prepare sql)

impl<'a> Debug for RBatisTxExecutor<'a>

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

Formats the value using the given formatter.

impl<'a> Deref for RBatisTxExecutor<'a>

type Target = DBTx<'a>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a> DerefMut for RBatisTxExecutor<'a>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'impl0, 'a> ExecutorMut for RBatisTxExecutor<'impl0>

fn exec<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    sql: &'life1 str,
    args: Vec<Bson>
) -> Pin<Box<dyn Future<Output = Result<DBExecResult, Error>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

fn fetch<'life0, 'life1, 'async_trait, T>(
    &'life0 mut self,
    sql: &'life1 str,
    args: Vec<Bson>
) -> Pin<Box<dyn Future<Output = Result<T, Error>> + Send + 'async_trait>> where
    T: DeserializeOwned,
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

impl<'r, 'inner> From<&'r mut RBatisTxExecutor<'inner>> for RbatisExecutor<'r, 'inner>

fn from(arg: &'r mut RBatisTxExecutor<'inner>) -> Self

Performs the conversion.

impl RbatisRef for RBatisTxExecutor<'_>

fn get_rbatis(&self) -> &Rbatis

fn driver_type(&self) -> Result<DriverType>

fn bind_arg<'arg>(
    &self,
    driver_type: &DriverType,
    sql: &'arg str,
    arg: Vec<Bson>
) -> Result<DBQuery<'arg>, Error>

bind arg into DBQuery