Trait rbatis::crud::CRUD[−][src]

pub trait CRUD {
#[must_use]    fn save_by_wrapper<'life0, 'life1, 'life2, 'life3, 'async_trait, T>(
        &'life0 self, 
        context_id: &'life1 str, 
        entity: &'life2 T, 
        w: &'life3 Wrapper
    ) -> 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,
        'life3: 'async_trait,
        Self: 'async_trait;

#[must_use]    fn save<'life0, 'life1, 'life2, 'async_trait, T>(
        &'life0 self, 
        context_id: &'life1 str, 
        entity: &'life2 T
    ) -> 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: 'async_trait;

#[must_use]    fn save_batch<'life0, 'life1, 'life2, 'async_trait, T>(
        &'life0 self, 
        context_id: &'life1 str, 
        entity: &'life2 [T]
    ) -> 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: 'async_trait;

#[must_use]    fn save_batch_slice<'life0, 'life1, 'life2, 'async_trait, T>(
        &'life0 self, 
        context_id: &'life1 str, 
        entity: &'life2 [T], 
        slice_len: usize
    ) -> 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: 'async_trait;

#[must_use]    fn remove_by_wrapper<'life0, 'life1, 'life2, 'async_trait, T>(
        &'life0 self, 
        context_id: &'life1 str, 
        w: &'life2 Wrapper
    ) -> 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: 'async_trait;

#[must_use]    fn remove_by_id<'life0, 'life1, 'life2, 'async_trait, T>(
        &'life0 self, 
        context_id: &'life1 str, 
        id: &'life2 T::IdType
    ) -> 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: 'async_trait;

#[must_use]    fn remove_batch_by_id<'life0, 'life1, 'life2, 'async_trait, T>(
        &'life0 self, 
        context_id: &'life1 str, 
        ids: &'life2 [T::IdType]
    ) -> 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: 'async_trait;

#[must_use]    fn update_by_wrapper<'life0, 'life1, 'life2, 'life3, 'async_trait, T>(
        &'life0 self, 
        context_id: &'life1 str, 
        arg: &'life2 mut T, 
        w: &'life3 Wrapper, 
        update_null_value: bool
    ) -> 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,
        'life3: 'async_trait,
        Self: 'async_trait;

#[must_use]    fn update_by_id<'life0, 'life1, 'life2, 'async_trait, T>(
        &'life0 self, 
        context_id: &'life1 str, 
        arg: &'life2 mut 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: 'async_trait;

#[must_use]    fn update_batch_by_id<'life0, 'life1, 'life2, 'async_trait, T>(
        &'life0 self, 
        context_id: &'life1 str, 
        ids: &'life2 mut [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: 'async_trait;

#[must_use]    fn fetch_by_id<'life0, 'life1, 'life2, 'async_trait, T>(
        &'life0 self, 
        context_id: &'life1 str, 
        id: &'life2 T::IdType
    ) -> Pin<Box<dyn Future<Output = Result<T>> + Send + 'async_trait>>
    where
        T: CRUDTable,
        T: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: 'async_trait;

#[must_use]    fn fetch_by_wrapper<'life0, 'life1, 'life2, 'async_trait, T>(
        &'life0 self, 
        context_id: &'life1 str, 
        w: &'life2 Wrapper
    ) -> Pin<Box<dyn Future<Output = Result<T>> + Send + 'async_trait>>
    where
        T: CRUDTable,
        T: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: 'async_trait;

#[must_use]    fn fetch_count_by_wrapper<'life0, 'life1, 'life2, 'async_trait, T>(
        &'life0 self, 
        context_id: &'life1 str, 
        w: &'life2 Wrapper
    ) -> 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: 'async_trait;

#[must_use]    fn fetch_page_by_wrapper<'life0, 'life1, 'life2, 'life3, 'async_trait, T>(
        &'life0 self, 
        context_id: &'life1 str, 
        w: &'life2 Wrapper, 
        page: &'life3 dyn IPageRequest
    ) -> Pin<Box<dyn Future<Output = Result<Page<T>>> + Send + 'async_trait>>
    where
        T: CRUDTable,
        T: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        'life3: 'async_trait,
        Self: 'async_trait;

#[must_use]    fn fetch_list<'life0, 'life1, 'async_trait, T>(
        &'life0 self, 
        context_id: &'life1 str
    ) -> Pin<Box<dyn Future<Output = Result<Vec<T>>> + Send + 'async_trait>>
    where
        T: CRUDTable,
        T: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        Self: 'async_trait;

#[must_use]    fn fetch_list_by_ids<'life0, 'life1, 'life2, 'async_trait, T>(
        &'life0 self, 
        context_id: &'life1 str, 
        ids: &'life2 [T::IdType]
    ) -> Pin<Box<dyn Future<Output = Result<Vec<T>>> + Send + 'async_trait>>
    where
        T: CRUDTable,
        T: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: 'async_trait;

#[must_use]    fn fetch_list_by_wrapper<'life0, 'life1, 'life2, 'async_trait, T>(
        &'life0 self, 
        context_id: &'life1 str, 
        w: &'life2 Wrapper
    ) -> Pin<Box<dyn Future<Output = Result<Vec<T>>> + Send + 'async_trait>>
    where
        T: CRUDTable,
        T: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
        'life2: 'async_trait,
        Self: 'async_trait;
}

Required methods

#[must_use]fn save_by_wrapper<'life0, 'life1, 'life2, 'life3, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    entity: &'life2 T,
    w: &'life3 Wrapper
) -> 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,
    'life3: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]fn save<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    entity: &'life2 T
) -> 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: 'async_trait, [src]

#[must_use]fn save_batch<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    entity: &'life2 [T]
) -> 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: 'async_trait, [src]

#[must_use]fn save_batch_slice<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    entity: &'life2 [T],
    slice_len: usize
) -> 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: 'async_trait, [src]

#[must_use]fn remove_by_wrapper<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    w: &'life2 Wrapper
) -> 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: 'async_trait, [src]

#[must_use]fn remove_by_id<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    id: &'life2 T::IdType
) -> 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: 'async_trait, [src]

#[must_use]fn remove_batch_by_id<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    ids: &'life2 [T::IdType]
) -> 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: 'async_trait, [src]

#[must_use]fn update_by_wrapper<'life0, 'life1, 'life2, 'life3, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    arg: &'life2 mut T,
    w: &'life3 Wrapper,
    update_null_value: bool
) -> 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,
    'life3: 'async_trait,
    Self: 'async_trait, [src]

#[must_use]fn update_by_id<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    arg: &'life2 mut 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: 'async_trait, [src]

update database record by id

#[must_use]fn update_batch_by_id<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    ids: &'life2 mut [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: 'async_trait, [src]

remove batch database record by args

#[must_use]fn fetch_by_id<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    id: &'life2 T::IdType
) -> Pin<Box<dyn Future<Output = Result<T>> + Send + 'async_trait>> where
    T: CRUDTable,
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, [src]

fetch database record by id

#[must_use]fn fetch_by_wrapper<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    w: &'life2 Wrapper
) -> Pin<Box<dyn Future<Output = Result<T>> + Send + 'async_trait>> where
    T: CRUDTable,
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, [src]

fetch database record by a wrapper

#[must_use]fn fetch_count_by_wrapper<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    w: &'life2 Wrapper
) -> 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: 'async_trait, [src]

count database record by a wrapper

#[must_use]fn fetch_page_by_wrapper<'life0, 'life1, 'life2, 'life3, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    w: &'life2 Wrapper,
    page: &'life3 dyn IPageRequest
) -> Pin<Box<dyn Future<Output = Result<Page<T>>> + Send + 'async_trait>> where
    T: CRUDTable,
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    Self: 'async_trait, [src]

fetch page database record list by a wrapper

#[must_use]fn fetch_list<'life0, 'life1, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<Vec<T>>> + Send + 'async_trait>> where
    T: CRUDTable,
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

fetch database record list for all

#[must_use]fn fetch_list_by_ids<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    ids: &'life2 [T::IdType]
) -> Pin<Box<dyn Future<Output = Result<Vec<T>>> + Send + 'async_trait>> where
    T: CRUDTable,
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, [src]

fetch database record list by a id array

#[must_use]fn fetch_list_by_wrapper<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    w: &'life2 Wrapper
) -> Pin<Box<dyn Future<Output = Result<Vec<T>>> + Send + 'async_trait>> where
    T: CRUDTable,
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, [src]

fetch database record list by a wrapper

Loading content...

Implementors

impl CRUD for Rbatis[src]

fn save_by_wrapper<'life0, 'life1, 'life2, 'life3, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    entity: &'life2 T,
    w: &'life3 Wrapper
) -> 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,
    'life3: 'async_trait,
    Self: 'async_trait, [src]

save by wrapper

fn save<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    entity: &'life2 T
) -> 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: 'async_trait, [src]

save one entity to database

fn save_batch<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    args: &'life2 [T]
) -> 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: 'async_trait, [src]

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

for Example: rb.save_batch(“”,&vec![activity]); [rbatis] Exec ==> insert into biz_activity (id,name,version) values ( ? , ? , ?),( ? , ? , ?)

fn save_batch_slice<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    args: &'life2 [T],
    slice_len: usize
) -> 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: 'async_trait, [src]

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

for Example: rb.save_batch_slice(“”,&vec![activity],0); [rbatis] Exec ==> insert into biz_activity (id,name,version) values ( ? , ? , ?),( ? , ? , ?)

fn remove_by_wrapper<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    w: &'life2 Wrapper
) -> 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: 'async_trait, [src]

remove database record by a wrapper

fn remove_by_id<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    id: &'life2 T::IdType
) -> 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: 'async_trait, [src]

remove database record by id

fn remove_batch_by_id<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    ids: &'life2 [T::IdType]
) -> 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: 'async_trait, [src]

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

fn update_by_wrapper<'life0, 'life1, 'life2, 'life3, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    arg: &'life2 mut T,
    w: &'life3 Wrapper,
    update_null_value: bool
) -> 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,
    'life3: 'async_trait,
    Self: 'async_trait, [src]

update arg by wrapper

fn update_by_id<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    arg: &'life2 mut 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: 'async_trait, [src]

update database record by id

fn update_batch_by_id<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    args: &'life2 mut [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: 'async_trait, [src]

remove batch database record by args

fn fetch_by_wrapper<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    w: &'life2 Wrapper
) -> Pin<Box<dyn Future<Output = Result<T>> + Send + 'async_trait>> where
    T: CRUDTable,
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, [src]

fetch database record by a wrapper

fn fetch_count_by_wrapper<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    w: &'life2 Wrapper
) -> 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: 'async_trait, [src]

count database record by a wrapper

fn fetch_by_id<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    id: &'life2 T::IdType
) -> Pin<Box<dyn Future<Output = Result<T>> + Send + 'async_trait>> where
    T: CRUDTable,
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, [src]

fetch database record by id

fn fetch_list_by_wrapper<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    w: &'life2 Wrapper
) -> Pin<Box<dyn Future<Output = Result<Vec<T>>> + Send + 'async_trait>> where
    T: CRUDTable,
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, [src]

fetch database record list by a wrapper

fn fetch_list<'life0, 'life1, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<Vec<T>>> + Send + 'async_trait>> where
    T: CRUDTable,
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, [src]

fetch database record list for all

fn fetch_list_by_ids<'life0, 'life1, 'life2, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    ids: &'life2 [T::IdType]
) -> Pin<Box<dyn Future<Output = Result<Vec<T>>> + Send + 'async_trait>> where
    T: CRUDTable,
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, [src]

fetch database record list by a id array

fn fetch_page_by_wrapper<'life0, 'life1, 'life2, 'life3, 'async_trait, T>(
    &'life0 self,
    context_id: &'life1 str,
    w: &'life2 Wrapper,
    page: &'life3 dyn IPageRequest
) -> Pin<Box<dyn Future<Output = Result<Page<T>>> + Send + 'async_trait>> where
    T: CRUDTable,
    T: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    Self: 'async_trait, [src]

fetch page database record list by a wrapper

Loading content...