Struct akita::Akita

pub struct Akita { /* fields omitted */ }

Implementations

impl Akita

pub fn new() -> Self

pub fn wrapper(self, wrapper: Wrapper) -> Self

pub fn conn(self, db: DatabasePlatform) -> Self

pub fn table<S: Into<String>>(self, table: S) -> Self

pub fn list<T>(&mut self) -> Result<Vec<T>, AkitaError> where
    T: FromValue, 

pub fn one<T>(&mut self) -> Result<Option<T>, AkitaError> where
    T: FromValue, 

Get one the table of records

pub fn page<T>(
    &mut self,
    page: usize,
    size: usize
) -> Result<IPage<T>, AkitaError> where
    T: FromValue, 

Get table of records with page

pub fn count(&mut self) -> Result<usize, AkitaError>

Get the total count of records

pub fn remove(&mut self) -> Result<(), AkitaError>

Remove the records by wrapper.

pub fn update(&mut self) -> Result<(), AkitaError>

Update the records by wrapper.

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

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

pub fn save_map<T>(&mut self, entity: &T) -> Result<(), AkitaError> where
    T: ToValue, 

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

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

Performs text query and maps each row of the first result set.

pub 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, 

Performs text query and maps each row of the first result set.

pub 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, 

Performs text query and folds the first result set to a single value.

pub fn query_iter<'a>(self) -> Result<Rows, AkitaError>

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

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

pub fn query_first<'a, R>(self) -> Result<R, AkitaError> where
    R: FromValue, 

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

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

pub fn query_first_opt<'a, R>(self) -> Result<Option<R>, AkitaError> where
    R: FromValue, 

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

pub fn build_update_clause(&mut self) -> Result<String, AkitaError>

build an update clause

pub fn build_insert_clause_map<T>(
    &mut self,
    entity: &T
) -> Result<String, AkitaError> where
    T: ToValue, 

build an insert clause

pub fn build_insert_clause<T>(
    &mut self,
    entities: &[&T]
) -> Result<String, AkitaError> where
    T: GetFields + ToValue, 

build an insert clause