Struct rbatis::wrapper::Wrapper

pub struct Wrapper {
    pub driver_type: DriverType,
    pub dml: String,
    pub sql: String,
    pub args: Vec<Bson>,
    pub formats: HashMap<String, fn(arg: &str) -> String>,
}

The packing/Wrapper of the SQL SQL passed into the Wrapper keep the keyword uppercase

for Example: let w = Wrapper::new(&DriverType::Mysql) .push_sql(“id == 1”) .eq(“id”, 1) .and() .ne(“id”, 1) .and() .in_array(“id”, &[1, 2, 3]) .in_(“id”, &[1, 2, 3]) .r#in(“id”, &[1, 2, 3]) .and() .not_in(“id”, &[1, 2, 3]) .and() .like(“name”, 1) .or() .not_like(“name”, “asdf”) .and() .between(“create_time”, “2020-01-01 00:00:00”, “2020-12-12 00:00:00”) .group_by(&[“id”]) .order_by(true, &[“id”, “name”]) ;

Fields

driver_type: DriverType

dml: String

sql: String

args: Vec<Bson>

formats: HashMap<String, fn(arg: &str) -> String>

Implementations

impl Wrapper

pub fn new(driver_type: &DriverType) -> Self

pub fn trim_value(self, from: &str, to: &str) -> Self

pub fn set_formats(
    self,
    formats: HashMap<String, fn(arg: &str) -> String>
) -> Self

pub fn set_dml(self, dml: &str) -> Self

pub fn push_wrapper(self, arg: Wrapper) -> Self

link left Wrapper to this Wrapper for Example: let w = Wrapper::new(&DriverType::Postgres).push_sql(“(”).eq(“a”, “1”).push_sql(“)”); let w2 = Wrapper::new(&DriverType::Postgres).eq(“b”, “2”) .and() .push_wrapper(w); println!(“sql:{:?}”, w2.sql.as_str()); // sql:“b = ? and (a = ?)” println!(“arg:{:?}”, w2.args.clone()); // arg:[String(“2”), String(“1”)]

pub fn push(self, sql: &str, args: Vec<Bson>) -> Self

push sql,args into self

pub fn do_if<'s, F>(self, test: bool, method: F) -> Self where
    F: FnOnce(Self) -> Self, 

do method,if test is true for example: let arg = 1; wrapper.do_if(true, |w| w.eq(“id”))

pub fn do_if_else<'s, F>(
    self,
    test: bool,
    method_if: F,
    method_else: fn(_: Self) -> Self
) -> Self where
    F: FnOnce(Self) -> Self, 

do method,if test is true for example: let arg = 1; wrapper.do_if(true, |w| w.eq(“id”),|w|w)

pub fn do_match<'s, F>(
    self,
    cases: &[(bool, fn(_: Wrapper) -> Wrapper)],
    default: F
) -> Self where
    F: FnOnce(Self) -> Self, 

match cases for example: let p = Option::::Some(1); let w = Wrapper::new(&DriverType::Postgres) .do_match(&[ (p == 0, |w| w.eq(“a”, “some”)), (p == 1, |w| w.eq(“a”, “some”)), ], |w| w.eq(“a”, “default”)) ;

pub fn set_sql(self, sql: &str) -> Self

pub fn push_sql(self, sql: &str) -> Self

pub fn set_args<T>(self, args: &[T]) -> Self where
    T: Serialize, 

pub fn push_arg<T>(self, arg: T) -> Self where
    T: Serialize, 

pub fn pop_arg(self) -> Self

pub fn not_allow_add_and_on_end(&self) -> bool

pub fn and(self) -> Self

link wrapper sql, if end with where , do nothing

pub fn or(self) -> Self

link wrapper sql, if end with where , do nothing

pub fn having(self, sql_having: &str) -> Self

pub fn all_eq<T>(self, arg: T) -> Self where
    T: Serialize, 

arg: JsonObject or struct{} or map[String,**]

pub fn do_format_column(&self, column: &str, data: &mut String)

format column

pub fn eq<T>(self, column: &str, obj: T) -> Self where
    T: Serialize, 

equal for example: eq(“a”,1) “ a = 1 “

pub fn ne<T>(self, column: &str, obj: T) -> Self where
    T: Serialize, 

not equal

pub fn order_by(self, is_asc: bool, columns: &[&str]) -> Self

pub fn group_by(self, columns: &[&str]) -> Self

pub fn gt<T>(self, column: &str, obj: T) -> Self where
    T: Serialize, 

sql: column > obj

pub fn ge<T>(self, column: &str, obj: T) -> Self where
    T: Serialize, 

sql: column >= obj

pub fn lt<T>(self, column: &str, obj: T) -> Self where
    T: Serialize, 

sql: column < obj

pub fn le<T>(self, column: &str, obj: T) -> Self where
    T: Serialize, 

sql: column <= obj

pub fn between<T>(self, column: &str, min: T, max: T) -> Self where
    T: Serialize, 

pub fn not_between<T>(self, column: &str, min: T, max: T) -> Self where
    T: Serialize, 

pub fn like<T>(self, column: &str, obj: T) -> Self where
    T: Serialize, 

pub fn like_left<T>(self, column: &str, obj: T) -> Self where
    T: Serialize, 

pub fn like_right<T>(self, column: &str, obj: T) -> Self where
    T: Serialize, 

pub fn not_like<T>(self, column: &str, obj: T) -> Self where
    T: Serialize, 

pub fn is_null(self, column: &str) -> Self

pub fn is_not_null(self, column: &str) -> Self

pub fn in_array<T>(self, column: &str, obj: &[T]) -> Self where
    T: Serialize, 

gen sql: * in (,,*)

pub fn in_<T>(self, column: &str, obj: &[T]) -> Self where
    T: Serialize, 

gen sql: * in (,,*)

pub fn in<T>(self, column: &str, obj: &[T]) -> Self where
    T: Serialize, 

gen sql: * in (,,*)

pub fn not_in<T>(self, column: &str, obj: &[T]) -> Self where
    T: Serialize, 

pub fn trim_space(self) -> Self

pub fn trim_and(self) -> Self

pub fn trim_or(self) -> Self

pub fn trim_and_or(self) -> Self

pub fn insert_into(self, table_name: &str, columns: &str, values: &str) -> Self

pub fn limit(self, limit: u64) -> Self

limit for example: limit(1) “ limit 1 “

Trait Implementations

impl Clone for Wrapper

fn clone(&self) -> Wrapper

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Wrapper

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.