Trait akita::Wrapper[−][src]

pub trait Wrapper {

Show 70 methods    fn eq<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<S: Into<String>, U: ToSegment>(
        &mut self, 
        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<S: Into<String>, U: ToSegment>(
        &mut self, 
        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<S: Into<String>, U: ToSegment>(
        &mut self, 
        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<S: Into<String>, U: ToSegment>(
        &mut self, 
        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<S: Into<String>, U: ToSegment>(
        &mut self, 
        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 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 first<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<S: Into<String>>(&mut self, sql: S) -> &mut Self;

    fn last_condition<S: Into<String>>(
        &mut self, 
        condition: bool, 
        sql: S
    ) -> &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 { ... }

}

Required methods

Provided methods

Implementors