Struct sqlx_model::Update

pub struct Update<'t, DB, T, CT> where
    T: ModelUpdateData<'t, DB, CT>,
    CT: UpdateData<'t, DB>,
    DB: Database,  {
    pub change: CT,
    // some fields omitted
}

更新操作

Fields

change: CT

Implementations

impl<'t, DB, T, CT> Update<'t, DB, T, CT> where
    T: ModelUpdateData<'t, DB, CT>,
    CT: UpdateData<'t, DB>,
    DB: Database, 

pub fn new(val: CT) -> Update<'t, DB, T, CT>

pub fn model<'q: 't>(val: &'q T, source: Option<&T>) -> Update<'t, DB, T, CT>

pub fn sql_sets(&self) -> String

pub fn sql_values_sets(&self) -> String

pub fn bind_values<'q>(
    &'q self,
    res: Query<'q, DB, <DB as HasArguments<'_>>::Arguments>
) -> Query<'q, DB, <DB as HasArguments<'_>>::Arguments>

pub async fn execute_by_scalar_pk<'c, PT>(
    &self,
    pk_scalar: PT,
    pool: &'c Pool<DB>
) -> Result<<DB as Database>::QueryResult, Error> where
    for<'q> PT: 'q + Send + Encode<'q, DB> + Type<DB>,
    for<'n> <DB as HasArguments<'n>>::Arguments: Arguments<'n> + IntoArguments<'n, DB>,
    &'c Pool<DB>: Executor<'c, Database = DB>, 

pub async fn execute_by_where_call<'c, RB>(
    &self,
    where_sql: &str,
    where_bind: RB,
    pool: &'c Pool<DB>
) -> Result<<DB as Database>::QueryResult, Error> where
    for<'q> RB: FnOnce(Query<'q, DB, <DB as HasArguments<'_>>::Arguments>, &'q Update<'_, DB, T, CT>) -> Query<'q, DB, <DB as HasArguments<'q>>::Arguments>,
    for<'n> <DB as HasArguments<'n>>::Arguments: Arguments<'n> + IntoArguments<'n, DB>,
    &'c Pool<DB>: Executor<'c, Database = DB>, 

pub async fn execute_by_where<'c>(
    &self,
    where_sql: Option<String>,
    pool: &'c Pool<DB>
) -> Result<<DB as Database>::QueryResult, Error> where
    for<'n> <DB as HasArguments<'n>>::Arguments: Arguments<'n> + IntoArguments<'n, DB>,
    &'c Pool<DB>: Executor<'c, Database = DB>, 

pub async fn execute_by_sql_call<'c, SQ, RB>(
    self,
    sql_call: SQ,
    bind_call: RB,
    pool: &'c Pool<DB>
) -> Result<<DB as Database>::QueryResult, Error> where
    SQ: FnOnce(&Update<'_, DB, T, CT>) -> String,
    for<'ct> RB: FnOnce(Query<'ct, DB, <DB as HasArguments<'_>>::Arguments>, &'ct Update<'_, DB, T, CT>) -> Query<'ct, DB, <DB as HasArguments<'ct>>::Arguments>,
    for<'n> <DB as HasArguments<'n>>::Arguments: Arguments<'n> + IntoArguments<'n, DB>,
    &'c Pool<DB>: Executor<'c, Database = DB>, 

pub async fn execute_by_sql<'c, SQ>(
    self,
    sql_call: SQ,
    pool: &'c Pool<DB>
) -> Result<<DB as Database>::QueryResult, Error> where
    SQ: FnOnce(&Update<'_, DB, T, CT>) -> String,
    for<'n> <DB as HasArguments<'n>>::Arguments: Arguments<'n> + IntoArguments<'n, DB>,
    &'c Pool<DB>: Executor<'c, Database = DB>, 

impl<'t, T, CT> Update<'t, MySql, T, CT> where
    T: ModelUpdateData<'t, MySql, CT>,
    CT: UpdateData<'t, MySql>, 

pub async fn execute_by_pk<'c>(
    &self,
    source: &T,
    pool: &'c Pool<MySql>
) -> Result<<MySql as Database>::QueryResult, Error>

impl<'t, T, CT> Update<'t, Sqlite, T, CT> where
    T: ModelUpdateData<'t, Sqlite, CT>,
    CT: UpdateData<'t, Sqlite>, 

pub async fn execute_by_pk<'c>(
    &self,
    source: &T,
    pool: &'c Pool<Sqlite>
) -> Result<<Sqlite as Database>::QueryResult, Error>

impl<'t, T, CT> Update<'t, Postgres, T, CT> where
    T: ModelUpdateData<'t, Postgres, CT>,
    CT: UpdateData<'t, Postgres>, 

pub async fn execute_by_pk<'c>(
    &self,
    source: &T,
    pool: &'c Pool<Postgres>
) -> Result<<Postgres as Database>::QueryResult, Error>

impl<'t, T, CT> Update<'t, Mssql, T, CT> where
    T: ModelUpdateData<'t, Mssql, CT>,
    CT: UpdateData<'t, Mssql>, 

pub async fn execute_by_pk<'c>(
    &self,
    source: &T,
    pool: &'c Pool<Mssql>
) -> Result<<Mssql as Database>::QueryResult, Error>