Struct akita::Akita

pub struct Akita { /* private fields */ }

Implementations

impl Akita

pub fn new(cfg: AkitaConfig) -> Result<Self, AkitaError>

pub fn from_pool(pool: &Pool) -> Result<Self, AkitaError>

pub fn start_transaction(&self) -> Result<AkitaTransaction<'_>, AkitaError>

pub fn get_pool(&self) -> Result<&PlatformPool, AkitaError>

get conn pool

pub fn acquire(&self) -> Result<DatabasePlatform, AkitaError>

get an DataBase Connection used for the next step

pub fn new_wrapper(&self) -> Wrapper

pub fn affected_rows(&self) -> u64

pub fn last_insert_id(&self) -> u64

Trait Implementations

impl AkitaMapper for Akita

fn list<T>(&self, wrapper: Wrapper) -> Result<Vec<T>, AkitaError> where
    T: GetTableName + GetFields + FromValue, 

Get all the table of records

fn select_one<T>(&self, wrapper: Wrapper) -> Result<Option<T>, AkitaError> where
    T: GetTableName + GetFields + FromValue, 

Get one the table of records

fn select_by_id<T, I>(&self, id: I) -> Result<Option<T>, AkitaError> where
    T: GetTableName + GetFields + FromValue,
    I: ToValue, 

Get one the table of records by id

fn page<T>(
    &self,
    page: usize,
    size: usize,
    wrapper: Wrapper
) -> Result<IPage<T>, AkitaError> where
    T: GetTableName + GetFields + FromValue, 

Get table of records with page

fn count<T>(&self, wrapper: Wrapper) -> Result<usize, AkitaError> where
    T: GetTableName + GetFields, 

Get the total count of records

fn remove<T>(&self, wrapper: Wrapper) -> Result<u64, AkitaError> where
    T: GetTableName + GetFields, 

Remove the records by wrapper.

fn remove_by_id<T, I>(&self, id: I) -> Result<u64, AkitaError> where
    I: ToValue,
    T: GetTableName + GetFields, 

Remove the records by id.

fn remove_by_ids<T, I>(&self, ids: Vec<I>) -> Result<u64, AkitaError> where
    I: ToValue,
    T: GetTableName + GetFields, 

Remove the records by wrapper.

fn update<T>(&self, entity: &T, wrapper: Wrapper) -> Result<u64, AkitaError> where
    T: GetTableName + GetFields + ToValue, 

Update the records by wrapper.

fn update_by_id<T>(&self, entity: &T) -> Result<u64, AkitaError> where
    T: GetTableName + GetFields + ToValue, 

Update the records by id.

fn save<T, I>(&self, entity: &T) -> Result<Option<I>, AkitaError> where
    T: GetTableName + GetFields + ToValue,
    I: FromValue, 

called multiple times when using database platform that doesn;t support multiple value

fn save_or_update<T, I>(&self, entity: &T) -> Result<Option<I>, AkitaError> where
    T: GetTableName + GetFields + ToValue,
    I: FromValue, 

save or update

fn save_batch<T>(&self, entities: &[&T]) -> Result<(), AkitaError> where
    T: GetTableName + GetFields + ToValue, 

fn exec_iter<S: Into<String>, P: Into<Params>>(
    &self,
    sql: S,
    params: P
) -> Result<Rows, AkitaError>

fn query_map<T, F, Q, U>(&self, query: Q, f: F) -> Result<Vec<U>, AkitaError> where
    Q: Into<String>,
    T: FromValue,
    F: FnMut(T) -> U, 

fn exec_map<T, F, Q, U>(&self, query: Q, f: F) -> Result<Vec<U>, AkitaError> where
    Q: Into<String>,
    T: FromValue,
    F: FnMut(T) -> U, 

fn query_fold<T, F, Q, U>(&self, query: Q, init: U, f: F) -> Result<U, AkitaError> where
    Q: Into<String>,
    T: FromValue,
    F: FnMut(U, T) -> U, 

fn query_iter<S: Into<String>>(&self, sql: S) -> Result<Rows, AkitaError>

fn exec_raw<R, S: Into<String>, P: Into<Params>>(
    &self,
    sql: S,
    params: P
) -> Result<Vec<R>, AkitaError> where
    R: FromValue, 

fn query_first<S: Into<String>, R>(&self, sql: S) -> Result<R, AkitaError> where
    R: FromValue, 

fn exec_first<R, S: Into<String>, P: Into<Params>>(
    &self,
    sql: S,
    params: P
) -> Result<R, AkitaError> where
    R: FromValue, 

fn exec_drop<S: Into<String>, P: Into<Params>>(
    &self,
    sql: S,
    params: P
) -> Result<(), AkitaError>

fn query_first_opt<R, S: Into<String>>(
    &self,
    sql: S
) -> Result<Option<R>, AkitaError> where
    R: FromValue, 

fn exec_first_opt<R, S: Into<String>, P: Into<Params>>(
    &self,
    sql: S,
    params: P
) -> Result<Option<R>, AkitaError> where
    R: FromValue,