Struct akita::UpdateWrapper

pub struct UpdateWrapper {
    pub param_name_seq: AtomicI32,
    pub sql_set: Vec<String>,
    pub sql_select: Option<String>,
    pub sql_comment: Option<String>,
    pub sql_first: Option<String>,
    pub last_sql: Option<String>,
    pub expression: MergeSegments,
}

Fields

param_name_seq: AtomicI32

必要度量

sql_set: Vec<String>

SQL set字段

sql_select: Option<String>

SQL查询字段

sql_comment: Option<String>

SQL注释

sql_first: Option<String>

SQL起始语句

last_sql: Option<String>

SQL结束语句

expression: MergeSegments

Implementations

impl UpdateWrapper

pub fn new() -> Self

pub fn set<S: Into<String>, U: ToSegment>(
    &mut self,
    column: S,
    val: U
) -> &mut Self

pub fn set_condition<S: Into<String>, U: ToSegment>(
    &mut self,
    condition: bool,
    column: S,
    val: U
) -> &mut Self

pub fn set_sql<S: Into<String>>(&mut self, condition: bool, sql: S) -> &mut Self

pub fn get_set_sql(&mut self) -> Option<String>

pub fn clear(&mut self)

pub fn get_target_sql(
    &mut self,
    table_name: &'static str
) -> Result<String, &str>

Trait Implementations

impl Wrapper for UpdateWrapper

fn eq<S: Into<String>, U: ToSegment>(&mut self, column: S, val: U) -> &mut Self

fn ne<S: Into<String>, U: ToSegment>(&mut self, column: S, val: U) -> &mut Self

fn gt<S: Into<String>, U: ToSegment>(&mut self, column: S, val: U) -> &mut Self

fn ge<S: Into<String>, U: ToSegment>(&mut self, column: S, val: U) -> &mut Self

fn lt<S: Into<String>, U: ToSegment>(&mut self, column: S, val: U) -> &mut Self

fn le<S: Into<String>, U: ToSegment>(&mut self, column: S, val: U) -> &mut Self

fn eq_condition<S: Into<String>, U: ToSegment>(
    &mut self,
    condition: bool,
    column: S,
    val: U
) -> &mut Self

fn ne_condition<S: Into<String>, U: ToSegment>(
    &mut self,
    condition: bool,
    column: S,
    val: U
) -> &mut Self

fn gt_condition<S: Into<String>, U: ToSegment>(
    &mut self,
    condition: bool,
    column: S,
    val: U
) -> &mut Self

fn ge_condition<S: Into<String>, U: ToSegment>(
    &mut self,
    condition: bool,
    column: S,
    val: U
) -> &mut Self

fn lt_condition<S: Into<String>, U: ToSegment>(
    &mut self,
    condition: bool,
    column: S,
    val: U
) -> &mut Self

fn le_condition<S: Into<String>, U: ToSegment>(
    &mut self,
    condition: bool,
    column: S,
    val: U
) -> &mut Self

fn first<S: Into<String>>(&mut self, sql: S) -> &mut Self

fn last<S: Into<String>>(&mut self, sql: S) -> &mut Self

fn first_condition<S: Into<String>>(
    &mut self,
    condition: bool,
    sql: S
) -> &mut Self

fn last_condition<S: Into<String>>(
    &mut self,
    condition: bool,
    sql: S
) -> &mut Self

fn inside<S: Into<String>, U: ToSegment + Clone>(
    &mut self,
    column: S,
    vals: Vec<U>
) -> &mut Self

fn in_condition<S: Into<String>, U: ToSegment + Clone>(
    &mut self,
    condition: bool,
    column: S,
    vals: Vec<U>
) -> &mut Self

fn append_sql_segments(&mut self, sql_segments: Vec<Segment>)

fn do_it(&mut self, condition: bool, segments: Vec<Segment>) -> &mut Self

fn get_sql_segment(&mut self) -> String

fn comment<S: Into<String>>(&mut self, comment: S) -> &mut Self

fn comment_condition<S: Into<String>>(
    &mut self,
    condition: bool,
    comment: S
) -> &mut Self

fn get_select_sql(&mut self) -> String

fn select(&mut self, columns: Vec<String>) -> &mut Self

fn not_in<S: Into<String>, U: ToSegment + Clone>(
    &mut self,
    column: S,
    vals: Vec<U>
) -> &mut Self

fn not_in_condition<S: Into<String>, U: ToSegment + Clone>(
    &mut self,
    condition: bool,
    column: S,
    vals: Vec<U>
) -> &mut Self

fn like<S: Into<String>, U: ToSegment>(
    &mut self,
    column: S,
    val: U
) -> &mut Self

fn like_condition<S: Into<String>, U: ToSegment>(
    &mut self,
    condition: bool,
    column: S,
    val: U
) -> &mut Self

fn not_like<S: Into<String>, U: ToSegment>(
    &mut self,
    column: S,
    val: U
) -> &mut Self

fn not_like_condition<S: Into<String>, U: ToSegment>(
    &mut self,
    condition: bool,
    column: S,
    val: U
) -> &mut Self

fn like_left<S: Into<String>, U: ToSegment>(
    &mut self,
    column: S,
    val: U
) -> &mut Self

fn like_left_condition<S: Into<String>, U: ToSegment>(
    &mut self,
    condition: bool,
    column: S,
    val: U
) -> &mut Self

fn like_right<S: Into<String>, U: ToSegment>(
    &mut self,
    column: S,
    val: U
) -> &mut Self

fn like_right_condition<S: Into<String>, U: ToSegment>(
    &mut self,
    condition: bool,
    column: S,
    val: U
) -> &mut Self

fn in_expression(&self, vals: Vec<Segment>) -> Segment

fn between<S: Into<String>, U: ToSegment>(
    &mut self,
    column: S,
    val1: U,
    val2: U
) -> &mut Self

fn between_condition<S: Into<String>, U: ToSegment>(
    &mut self,
    condition: bool,
    column: S,
    val1: U,
    val2: U
) -> &mut Self

fn not_between<S: Into<String>, U: ToSegment>(
    &mut self,
    column: S,
    val1: U,
    val2: U
) -> &mut Self

fn not_between_condition<S: Into<String>, U: ToSegment>(
    &mut self,
    condition: bool,
    column: S,
    val1: U,
    val2: U
) -> &mut Self

fn add_condition(
    &mut self,
    condition: bool,
    column: Segment,
    sql_keword: SqlKeyword,
    val: Segment
) -> &mut Self

fn like_value(
    &mut self,
    condition: bool,
    column: Segment,
    sql_like: SqlLike,
    val: Segment
) -> &mut Self

fn not(&mut self) -> &mut Self

fn and(&mut self) -> &mut Self

fn or(&mut self) -> &mut Self

fn not_condition(&mut self, condition: bool) -> &mut Self

fn and_condition(&mut self, condition: bool) -> &mut Self

fn or_condition(&mut self, condition: bool) -> &mut Self

fn apply<S: Into<String>>(&mut self, apply_sql: S) -> &mut Self

fn apply_condition<S: Into<String>>(
    &mut self,
    condition: bool,
    apply_sql: S
) -> &mut Self

fn is_null<S: Into<String>>(&mut self, column: S) -> &mut Self

fn is_null_condition<S: Into<String>>(
    &mut self,
    condition: bool,
    column: S
) -> &mut Self

fn is_not_null<S: Into<String>>(&mut self, column: S) -> &mut Self

fn is_not_null_condition<S: Into<String>>(
    &mut self,
    condition: bool,
    column: S
) -> &mut Self

fn not_exists<S: Into<String>>(&mut self, not_exists_sql: S) -> &mut Self

fn not_exists_condition<S: Into<String>>(
    &mut self,
    condition: bool,
    not_exists_sql: S
) -> &mut Self

fn exists<S: Into<String>>(&mut self, exists_sql: S) -> &mut Self

fn exists_condition<S: Into<String>>(
    &mut self,
    condition: bool,
    exists_sql: S
) -> &mut Self

fn in_sql<S: Into<String>, U: Into<String>>(
    &mut self,
    column: S,
    in_val: U
) -> &mut Self

fn in_sql_condition<S: Into<String>, U: Into<String>>(
    &mut self,
    condition: bool,
    column: S,
    in_val: U
) -> &mut Self

fn group_by<S: Into<String> + Clone>(&mut self, columns: Vec<S>) -> &mut Self

fn group_by_condition<S: Into<String> + Clone>(
    &mut self,
    condition: bool,
    columns: Vec<S>
) -> &mut Self

fn having<S: Into<String>>(&mut self, sql_having: S) -> &mut Self

fn having_condition<S: Into<String>>(
    &mut self,
    condition: bool,
    sql_having: S
) -> &mut Self

fn order_by<S: Into<String> + Clone>(
    &mut self,
    is_asc: bool,
    columns: Vec<S>
) -> &mut Self

fn asc_by<S: Into<String> + Clone>(&mut self, columns: Vec<S>) -> &mut Self

fn desc_by<S: Into<String> + Clone>(&mut self, columns: Vec<S>) -> &mut Self

fn order_by_condition<S: Into<String> + Clone>(
    &mut self,
    condition: bool,
    is_asc: bool,
    columns: Vec<S>
) -> &mut Self

fn asc_by_condition<S: Into<String> + Clone>(
    &mut self,
    condition: bool,
    columns: Vec<S>
) -> &mut Self

fn desc_by_condition<S: Into<String> + Clone>(
    &mut self,
    condition: bool,
    columns: Vec<S>
) -> &mut Self