[INFO] cloning repository https://github.com/lmmqxyx404/Backend
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/lmmqxyx404/Backend" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Flmmqxyx404%2FBackend", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Flmmqxyx404%2FBackend'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] adb6d13d3f48302c6f9f503e1ca067eba603fa6b
[INFO] testing lmmqxyx404/Backend against 1.75.0 for beta-1.76-3
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Flmmqxyx404%2FBackend" "/workspace/builds/worker-0-tc1/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-0-tc1/source'...
[INFO] [stderr] done.
[INFO] validating manifest of git repo https://github.com/lmmqxyx404/Backend on toolchain 1.75.0
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+1.75.0" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] started tweaking git repo https://github.com/lmmqxyx404/Backend
[INFO] finished tweaking git repo https://github.com/lmmqxyx404/Backend
[INFO] tweaked toml for git repo https://github.com/lmmqxyx404/Backend written to /workspace/builds/worker-0-tc1/source/Cargo.toml
[INFO] crate git repo https://github.com/lmmqxyx404/Backend already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+1.75.0" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Updating crates.io index
[INFO] [stderr]  Downloading crates ...
[INFO] [stderr]   Downloaded time-macros v0.2.7
[INFO] [stderr]   Downloaded signature v2.0.0
[INFO] [stderr]   Downloaded pem v1.1.1
[INFO] [stderr]   Downloaded quickcheck v1.0.3
[INFO] [stderr]   Downloaded rust-format v0.3.4
[INFO] [stderr]   Downloaded rsa v0.8.1
[INFO] [stderr]   Downloaded cxxbridge-flags v1.0.91
[INFO] [stderr]   Downloaded pest_generator v2.5.5
[INFO] [stderr]   Downloaded rmp v0.8.11
[INFO] [stderr]   Downloaded rbs v0.1.15
[INFO] [stderr]   Downloaded async-trait v0.1.64
[INFO] [stderr]   Downloaded tokio-util v0.7.7
[INFO] [stderr]   Downloaded zstd-sys v2.0.7+zstd.1.5.4
[INFO] [stderr]   Downloaded captcha v0.0.8
[INFO] [stderr]   Downloaded decimal v2.1.0
[INFO] [stderr]   Downloaded serde_json v1.0.93
[INFO] [stderr]   Downloaded fast_log v1.5.51
[INFO] [stderr]   Downloaded rbatis-macro-driver v4.0.16
[INFO] [stderr]   Downloaded cxx-build v1.0.91
[INFO] [stderr]   Downloaded num-bigint-dig v0.8.2
[INFO] [stderr]   Downloaded actix-http v3.3.0
[INFO] [stderr]   Downloaded actix-web v4.3.0
[INFO] [stderr]   Downloaded rbatis-codegen v4.0.34
[INFO] [stderr]   Downloaded rayon v1.6.1
[INFO] [stderr]   Downloaded pest v2.5.5
[INFO] [stderr]   Downloaded rayon-core v1.10.2
[INFO] [stderr]   Downloaded lodepng v3.7.2
[INFO] [stderr]   Downloaded cxx v1.0.91
[INFO] [stderr]   Downloaded time v0.3.19
[INFO] [stderr]   Downloaded rbatis v4.0.50
[INFO] [stderr]   Downloaded redis v0.21.7
[INFO] [stderr]   Downloaded const-oid v0.9.1
[INFO] [stderr]   Downloaded base64ct v1.5.3
[INFO] [stderr]   Downloaded zip v0.6.4
[INFO] [stderr]   Downloaded hashlink v0.8.1
[INFO] [stderr]   Downloaded pkcs1 v0.4.1
[INFO] [stderr]   Downloaded semver v1.0.16
[INFO] [stderr]   Downloaded bytemuck v1.13.0
[INFO] [stderr]   Downloaded cxxbridge-macro v1.0.91
[INFO] [stderr]   Downloaded crossbeam-epoch v0.9.13
[INFO] [stderr]   Downloaded futures-executor v0.3.26
[INFO] [stderr]   Downloaded fallible_collections v0.4.6
[INFO] [stderr]   Downloaded jsonwebtoken v8.2.0
[INFO] [stderr]   Downloaded spin v0.9.5
[INFO] [stderr]   Downloaded futures v0.3.26
[INFO] [stderr]   Downloaded pest_meta v2.5.5
[INFO] [stderr]   Downloaded html_parser v0.6.3
[INFO] [stderr]   Downloaded paste v1.0.11
[INFO] [stderr]   Downloaded ord_subset v3.1.1
[INFO] [stderr]   Downloaded serde_bytes v0.11.9
[INFO] [stderr]   Downloaded fastdate v0.1.33
[INFO] [stderr]   Downloaded rbdc v0.1.22
[INFO] [stderr]   Downloaded pem-rfc7468 v0.6.0
[INFO] [stderr]   Downloaded simple_asn1 v0.6.2
[INFO] [stderr]   Downloaded dark-std v0.2.3
[INFO] [stderr]   Downloaded pest_derive v2.5.5
[INFO] [stderr]   Downloaded rgb v0.8.35
[INFO] [stderr]   Downloaded rbdc-mysql v0.1.20
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:2788e3201cd34a07e3172128adcd8b3090168a8e3bcc40d7c032b9dda1df7d1c" "/opt/rustwide/cargo-home/bin/cargo" "+1.75.0" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stdout] 8d2bf45d280203284071a84cc26f085bd0eee7b8a37bc705d811ab9ed72bbbb3
[INFO] running `Command { std: "docker" "start" "-a" "8d2bf45d280203284071a84cc26f085bd0eee7b8a37bc705d811ab9ed72bbbb3", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "8d2bf45d280203284071a84cc26f085bd0eee7b8a37bc705d811ab9ed72bbbb3", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "8d2bf45d280203284071a84cc26f085bd0eee7b8a37bc705d811ab9ed72bbbb3", kill_on_drop: false }`
[INFO] [stdout] 8d2bf45d280203284071a84cc26f085bd0eee7b8a37bc705d811ab9ed72bbbb3
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=warn" "-e" "RUSTDOCFLAGS=--cap-lints=warn" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:2788e3201cd34a07e3172128adcd8b3090168a8e3bcc40d7c032b9dda1df7d1c" "/opt/rustwide/cargo-home/bin/cargo" "+1.75.0" "build" "--frozen" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] 0a19490145e1416d7025952be1ae1d23d3ad3c960bec99049c3d3969f90aec12
[INFO] running `Command { std: "docker" "start" "-a" "0a19490145e1416d7025952be1ae1d23d3ad3c960bec99049c3d3969f90aec12", kill_on_drop: false }`
[INFO] [stderr]    Compiling libc v0.2.139
[INFO] [stderr]    Compiling proc-macro2 v1.0.51
[INFO] [stderr]    Compiling unicode-ident v1.0.6
[INFO] [stderr]    Compiling quote v1.0.23
[INFO] [stderr]    Compiling syn v1.0.107
[INFO] [stderr]    Compiling once_cell v1.17.1
[INFO] [stderr]    Compiling memchr v2.5.0
[INFO] [stderr]    Compiling log v0.4.17
[INFO] [stderr]    Compiling serde_derive v1.0.152
[INFO] [stderr]    Compiling serde v1.0.152
[INFO] [stderr]    Compiling pin-project-lite v0.2.9
[INFO] [stderr]    Compiling itoa v1.0.5
[INFO] [stderr]    Compiling futures-core v0.3.26
[INFO] [stderr]    Compiling lock_api v0.4.9
[INFO] [stderr]    Compiling smallvec v1.10.0
[INFO] [stderr]    Compiling typenum v1.16.0
[INFO] [stderr]    Compiling bytes v1.4.0
[INFO] [stderr]    Compiling parking_lot_core v0.9.7
[INFO] [stderr]    Compiling libm v0.2.6
[INFO] [stderr]    Compiling num-traits v0.2.15
[INFO] [stderr]    Compiling generic-array v0.14.6
[INFO] [stderr]    Compiling futures-sink v0.3.26
[INFO] [stderr]    Compiling const-oid v0.9.1
[INFO] [stderr]    Compiling tokio v1.25.0
[INFO] [stderr]    Compiling regex-syntax v0.6.28
[INFO] [stderr]    Compiling paste v1.0.11
[INFO] [stderr]    Compiling crossbeam-utils v0.8.14
[INFO] [stderr]    Compiling ahash v0.7.6
[INFO] [stderr]    Compiling ppv-lite86 v0.2.17
[INFO] [stderr]    Compiling memoffset v0.7.1
[INFO] [stderr]    Compiling slab v0.4.7
[INFO] [stderr]    Compiling ryu v1.0.12
[INFO] [stderr]    Compiling futures-channel v0.3.26
[INFO] [stderr]    Compiling subtle v2.4.1
[INFO] [stderr]    Compiling futures-task v0.3.26
[INFO] [stderr]    Compiling crossbeam-epoch v0.9.13
[INFO] [stderr]    Compiling num-integer v0.1.45
[INFO] [stderr]    Compiling aho-corasick v0.7.20
[INFO] [stderr]    Compiling futures-util v0.3.26
[INFO] [stderr]    Compiling spin v0.5.2
[INFO] [stderr]    Compiling thiserror v1.0.38
[INFO] [stderr]    Compiling jobserver v0.1.25
[INFO] [stderr]    Compiling getrandom v0.2.8
[INFO] [stderr]    Compiling num_cpus v1.15.0
[INFO] [stderr]    Compiling signal-hook-registry v1.4.1
[INFO] [stderr]    Compiling mio v0.8.6
[INFO] [stderr]    Compiling socket2 v0.4.7
[INFO] [stderr]    Compiling cc v1.0.79
[INFO] [stderr]    Compiling rand_core v0.6.4
[INFO] [stderr]    Compiling parking_lot v0.12.1
[INFO] [stderr]    Compiling futures-io v0.3.26
[INFO] [stderr]    Compiling pin-utils v0.1.0
[INFO] [stderr]    Compiling pkg-config v0.3.26
[INFO] [stderr]    Compiling serde_json v1.0.93
[INFO] [stderr]    Compiling rand_chacha v0.3.1
[INFO] [stderr]    Compiling hashbrown v0.12.3
[INFO] [stderr]    Compiling regex v1.7.1
[INFO] [stderr]    Compiling base64ct v1.5.3
[INFO] [stderr]    Compiling percent-encoding v2.2.0
[INFO] [stderr]    Compiling tinyvec_macros v0.1.1
[INFO] [stderr]    Compiling crossbeam-deque v0.8.2
[INFO] [stderr]    Compiling rand v0.8.5
[INFO] [stderr]    Compiling tinyvec v1.6.0
[INFO] [stderr]    Compiling crossbeam-channel v0.5.6
[INFO] [stderr]    Compiling tracing-core v0.1.30
[INFO] [stderr]    Compiling untrusted v0.7.1
[INFO] [stderr]    Compiling async-trait v0.1.64
[INFO] [stderr]    Compiling cpufeatures v0.2.5
[INFO] [stderr]    Compiling form_urlencoded v1.1.0
[INFO] [stderr]    Compiling adler v1.0.2
[INFO] [stderr]    Compiling unicode-bidi v0.3.10
[INFO] [stderr]    Compiling base64 v0.21.0
[INFO] [stderr]    Compiling ucd-trie v0.1.5
[INFO] [stderr]    Compiling ring v0.16.20
[INFO] [stderr]    Compiling crypto-common v0.1.6
[INFO] [stderr]    Compiling block-buffer v0.10.3
[INFO] [stderr]    Compiling zstd-sys v2.0.7+zstd.1.5.4
[INFO] [stderr]    Compiling digest v0.10.6
[INFO] [stderr]    Compiling env_logger v0.8.4
[INFO] [stderr]    Compiling tracing v0.1.37
[INFO] [stderr]    Compiling num-iter v0.1.43
[INFO] [stderr]    Compiling zeroize v1.5.7
[INFO] [stderr]    Compiling fnv v1.0.7
[INFO] [stderr]    Compiling rayon-core v1.10.2
[INFO] [stderr]    Compiling time-core v0.1.0
[INFO] [stderr]    Compiling http v0.2.9
[INFO] [stderr]    Compiling unicode-normalization v0.1.22
[INFO] [stderr]    Compiling time-macros v0.2.7
[INFO] [stderr]    Compiling pem-rfc7468 v0.6.0
[INFO] [stderr]    Compiling indexmap v1.9.2
[INFO] [stderr]    Compiling rustls v0.20.8
[INFO] [stderr]    Compiling getrandom v0.1.16
[INFO] [stderr]    Compiling crossbeam-queue v0.3.8
[INFO] [stderr]    Compiling either v1.8.1
[INFO] [stderr]    Compiling der v0.6.1
[INFO] [stderr]    Compiling quickcheck v1.0.3
[INFO] [stderr]    Compiling idna v0.3.0
[INFO] [stderr]    Compiling miniz_oxide v0.6.2
[INFO] [stderr]    Compiling bzip2-sys v0.1.11+1.0.8
[INFO] [stderr]    Compiling rmp v0.8.11
[INFO] [stderr]    Compiling bytestring v1.2.0
[INFO] [stderr]    Compiling miniz_oxide v0.4.4
[INFO] [stderr]    Compiling zstd-safe v5.0.2+zstd.1.5.2
[INFO] [stderr]    Compiling local-waker v0.1.3
[INFO] [stderr]    Compiling rayon v1.6.1
[INFO] [stderr]    Compiling url v2.3.1
[INFO] [stderr]    Compiling flate2 v1.0.25
[INFO] [stderr]    Compiling time v0.3.19
[INFO] [stderr]    Compiling sha2 v0.10.6
[INFO] [stderr]    Compiling sha1 v0.10.5
[INFO] [stderr]    Compiling lz4-sys v1.9.4
[INFO] [stderr]    Compiling spki v0.6.0
[INFO] [stderr]    Compiling spin v0.9.5
[INFO] [stderr]    Compiling num-bigint v0.4.3
[INFO] [stderr]    Compiling retain_mut v0.1.9
[INFO] [stderr]    Compiling weezl v0.1.7
[INFO] [stderr]    Compiling deadpool-runtime v0.1.2
[INFO] [stderr]    Compiling num-bigint-dig v0.8.2
[INFO] [stderr]    Compiling bytemuck v1.13.0
[INFO] [stderr]    Compiling httparse v1.8.0
[INFO] [stderr]    Compiling pkcs8 v0.9.0
[INFO] [stderr]    Compiling crossbeam v0.8.2
[INFO] [stderr]    Compiling rand_core v0.5.1
[INFO] [stderr]    Compiling actix-utils v3.0.1
[INFO] [stderr]    Compiling hmac v0.12.1
[INFO] [stderr]    Compiling rustls-pemfile v1.0.2
[INFO] [stderr]    Compiling cipher v0.3.0
[INFO] [stderr]    Compiling decimal v2.1.0
[INFO] [stderr]    Compiling hashlink v0.8.1
[INFO] [stderr]    Compiling password-hash v0.4.2
[INFO] [stderr]    Compiling actix-service v2.0.2
[INFO] [stderr]    Compiling uuid v1.3.0
[INFO] [stderr]    Compiling lazy_static v1.4.0
[INFO] [stderr]    Compiling base64 v0.13.1
[INFO] [stderr]    Compiling convert_case v0.4.0
[INFO] [stderr]    Compiling opaque-debug v0.3.0
[INFO] [stderr]    Compiling aes v0.7.5
[INFO] [stderr]    Compiling gif v0.11.4
[INFO] [stderr]    Compiling pbkdf2 v0.11.0
[INFO] [stderr]    Compiling rand_chacha v0.2.2
[INFO] [stderr]    Compiling pkcs1 v0.4.1
[INFO] [stderr]    Compiling rgb v0.8.35
[INFO] [stderr]    Compiling num-rational v0.3.2
[INFO] [stderr]    Compiling jpeg-decoder v0.1.22
[INFO] [stderr]    Compiling signature v2.0.0
[INFO] [stderr]    Compiling fallible_collections v0.4.6
[INFO] [stderr]    Compiling encoding_rs v0.8.32
[INFO] [stderr]    Compiling scoped_threadpool v0.1.9
[INFO] [stderr]    Compiling hex v0.4.3
[INFO] [stderr]    Compiling httpdate v1.0.2
[INFO] [stderr]    Compiling mime v0.3.16
[INFO] [stderr]    Compiling tokio-macros v1.8.2
[INFO] [stderr]    Compiling thiserror-impl v1.0.38
[INFO] [stderr]    Compiling futures-macro v0.3.26
[INFO] [stderr]    Compiling webpki v0.22.0
[INFO] [stderr]    Compiling sct v0.7.0
[INFO] [stderr]    Compiling pin-project-internal v1.0.12
[INFO] [stderr]    Compiling webpki-roots v0.22.6
[INFO] [stderr]    Compiling derive_more v0.99.17
[INFO] [stderr]    Compiling tiff v0.6.1
[INFO] [stderr]    Compiling sha1_smol v1.0.0
[INFO] [stderr]    Compiling language-tags v0.3.2
[INFO] [stderr]    Compiling rust-format v0.3.4
[INFO] [stderr]    Compiling linked-hash-map v0.5.6
[INFO] [stderr]    Compiling ord_subset v3.1.1
[INFO] [stderr]    Compiling constant_time_eq v0.1.5
[INFO] [stderr]    Compiling yaml-rust v0.4.5
[INFO] [stderr]    Compiling sha1 v0.6.1
[INFO] [stderr]    Compiling rsa v0.8.1
[INFO] [stderr]    Compiling actix-macros v0.2.3
[INFO] [stderr]    Compiling image v0.23.14
[INFO] [stderr]    Compiling lodepng v3.7.2
[INFO] [stderr]    Compiling pest v2.5.5
[INFO] [stderr]    Compiling simple_asn1 v0.6.2
[INFO] [stderr]    Compiling rand v0.7.3
[INFO] [stderr]    Compiling pem v1.1.1
[INFO] [stderr]    Compiling sha-1 v0.10.1
[INFO] [stderr]    Compiling time v0.1.45
[INFO] [stderr]    Compiling pin-project v1.0.12
[INFO] [stderr]    Compiling pest_meta v2.5.5
[INFO] [stderr]    Compiling flume v0.10.14
[INFO] [stderr]    Compiling iana-time-zone v0.1.53
[INFO] [stderr]    Compiling hound v3.5.0
[INFO] [stderr]    Compiling md5 v0.7.0
[INFO] [stderr]    Compiling pest_generator v2.5.5
[INFO] [stderr]    Compiling local-channel v0.1.3
[INFO] [stderr]    Compiling futures-executor v0.3.26
[INFO] [stderr]    Compiling pest_derive v2.5.5
[INFO] [stderr]    Compiling futures v0.3.26
[INFO] [stderr]    Compiling bzip2 v0.4.4
[INFO] [stderr]    Compiling tokio-util v0.7.7
[INFO] [stderr]    Compiling actix-rt v2.8.0
[INFO] [stderr]    Compiling deadpool v0.9.5
[INFO] [stderr]    Compiling tokio-rustls v0.23.4
[INFO] [stderr]    Compiling actix-server v2.2.0
[INFO] [stderr]    Compiling h2 v0.3.15
[INFO] [stderr]    Compiling actix-codec v0.5.0
[INFO] [stderr]    Compiling combine v4.6.6
[INFO] [stderr]    Compiling serde_bytes v0.11.9
[INFO] [stderr]    Compiling fastdate v0.1.33
[INFO] [stderr]    Compiling actix-router v0.5.1
[INFO] [stderr]    Compiling dark-std v0.2.3
[INFO] [stderr]    Compiling serde_urlencoded v0.7.1
[INFO] [stderr]    Compiling chrono v0.4.23
[INFO] [stderr]    Compiling serde_yaml v0.8.26
[INFO] [stderr]    Compiling rbs v0.1.15
[INFO] [stderr]    Compiling actix-web-codegen v4.1.0
[INFO] [stderr]    Compiling zstd v0.11.2+zstd.1.5.2
[INFO] [stderr]    Compiling html_parser v0.6.3
[INFO] [stderr]    Compiling rbdc v0.1.22
[INFO] [stderr]    Compiling captcha v0.0.8
[INFO] [stderr]    Compiling jsonwebtoken v8.2.0
[INFO] [stderr]    Compiling zip v0.6.4
[INFO] [stderr]    Compiling rbatis-codegen v4.0.34
[INFO] [stderr]    Compiling lz4 v1.24.0
[INFO] [stderr]    Compiling rbdc-mysql v0.1.20
[INFO] [stderr]    Compiling fast_log v1.5.51
[INFO] [stderr]    Compiling redis v0.21.7
[INFO] [stderr]    Compiling rbatis-macro-driver v4.0.16
[INFO] [stderr]    Compiling actix-http v3.3.0
[INFO] [stderr]    Compiling rbatis v4.0.50
[INFO] [stderr]    Compiling actix-web v4.3.0
[INFO] [stderr]    Compiling backend v0.1.0 (/opt/rustwide/workdir)
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] insert_batch(rb : & mut dyn rbatis :: executor :: Executor, tables : &
[INFO] [stdout] [SysRes], table_name : & str,) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("tables".to_string().into(), rbs ::
[INFO] [stdout]     to_value(tables).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(65usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("insert into ${table_name} ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(35usize) ; for(idx, table)
[INFO] [stdout]             in { & arg ["tables"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if { (idx).op_eq(& 0i64) }.to_owned().into()
[INFO] [stdout]                 {
[INFO] [stdout]                     sql.push_str("(") ;
[INFO] [stdout]                     sql.push_str(&
[INFO] [stdout]                     {
[INFO] [stdout]                         let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                         { table }
[INFO] [stdout]                         {
[INFO] [stdout]                             if
[INFO] [stdout]                             {
[INFO] [stdout]                                 bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                                 op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                             }.to_owned().into() { continue }
[INFO] [stdout]                             sql.push_str("${k},".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                             1).as_str()) ;
[INFO] [stdout]                         } sql =
[INFO] [stdout]                         sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                         ; sql
[INFO] [stdout]                     }) ; sql.push_str(") VALUES ") ;
[INFO] [stdout]                 } sql.push_str("(") ;
[INFO] [stdout]                 sql.push_str(&
[INFO] [stdout]                 {
[INFO] [stdout]                     let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                     { table }
[INFO] [stdout]                     {
[INFO] [stdout]                         if
[INFO] [stdout]                         {
[INFO] [stdout]                             bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                             op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                         }.to_owned().into() { continue }
[INFO] [stdout]                         args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                         sql.push_str("?,") ;
[INFO] [stdout]                     } sql =
[INFO] [stdout]                     sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                     ; sql
[INFO] [stdout]                 }) ; sql.push_str("),") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_all(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str,) -> std :: result :: Result < Vec < SysRes >, rbatis
[INFO] [stdout] :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(44usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} ".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_value : V,) -> std :: result ::
[INFO] [stdout] Result < Vec < SysRes >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} = ?".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_values : & [V],) -> std :: result
[INFO] [stdout] :: Result < Vec < SysRes >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} in (".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] update_by_column_value(rb : & mut dyn rbatis :: executor :: Executor,
[INFO] [stdout] table_name : String, table : & rbs :: Value, column : & str, column_value :
[INFO] [stdout] & rbs :: Value,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(77usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("update ${table_name} set ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(12usize) ; for(k, v) in
[INFO] [stdout]             { & arg ["table"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if
[INFO] [stdout]                 {
[INFO] [stdout]                     bool :: op_from((k).op_eq(& & arg ["column"])) || bool ::
[INFO] [stdout]                     op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                 }.to_owned().into() { continue }
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("${k}=?,".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                 1).as_str()) ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str(" where ${column} = ?".replacen("${column}", &
[INFO] [stdout]         { & arg ["column"] }.as_sql(), 1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_value : V,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} = ?".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column_batch < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(60usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(7usize) ; for(_, v) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_page(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str, dto : & crate :: domain :: dto :: res :: ResPageDTO,)
[INFO] [stdout] -> std :: result :: Result < u64, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("dto".to_string().into(), rbs ::
[INFO] [stdout]     to_value(dto).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(152usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select count(1) as count from ${table_name} where del = 0 ".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(), 1).as_str()) ; if
[INFO] [stdout]         {
[INFO] [stdout]             bool ::
[INFO] [stdout]             op_from(((& arg ["dto"] ["name"])).op_ne(& rbs :: Value :: Null))
[INFO] [stdout]             && bool :: op_from(((& arg ["dto"] ["name"])).op_ne(& ""))
[INFO] [stdout]         }.to_owned().into() {}
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({
[INFO] [stdout]             ((String ::
[INFO] [stdout]             from("%")).op_add((& arg ["dto"] ["name"]))).op_add(& "%")
[INFO] [stdout]         }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str(" and name like ?and parent_id IS NULL") ; if
[INFO] [stdout]         { ! sql.contains("count") }.to_owned().into() {}
[INFO] [stdout]         sql.push_str("order by create_date desc") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_page(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str, page_no : u64, page_size : u64, page_offset : u64,
[INFO] [stdout] limit_sql : & str, dto : & crate :: domain :: dto :: res :: ResPageDTO,) ->
[INFO] [stdout] std :: result :: Result < Vec < SysRes >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("page_no".to_string().into(), rbs ::
[INFO] [stdout]     to_value(page_no).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("page_size".to_string().into(), rbs ::
[INFO] [stdout]     to_value(page_size).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("page_offset".to_string().into(), rbs ::
[INFO] [stdout]     to_value(page_offset).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("limit_sql".to_string().into(), rbs ::
[INFO] [stdout]     to_value(limit_sql).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("dto".to_string().into(), rbs ::
[INFO] [stdout]     to_value(dto).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(164usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} where del = 0 ".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; if
[INFO] [stdout]         {
[INFO] [stdout]             bool ::
[INFO] [stdout]             op_from(((& arg ["dto"] ["name"])).op_ne(& rbs :: Value :: Null))
[INFO] [stdout]             && bool :: op_from(((& arg ["dto"] ["name"])).op_ne(& ""))
[INFO] [stdout]         }.to_owned().into() {}
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({
[INFO] [stdout]             ((String ::
[INFO] [stdout]             from("%")).op_add((& arg ["dto"] ["name"]))).op_add(& "%")
[INFO] [stdout]         }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str(" and name like ?and parent_id IS NULL") ; if
[INFO] [stdout]         { ! sql.contains("count") }.to_owned().into() {}
[INFO] [stdout]         sql.push_str("order by create_date desc") ; if
[INFO] [stdout]         {
[INFO] [stdout]             bool :: op_from(! sql.contains("page_no")) && bool ::
[INFO] [stdout]             op_from(! sql.contains("page_size"))
[INFO] [stdout]         }.to_owned().into()
[INFO] [stdout]         {
[INFO] [stdout]             sql.push_str("${limit_sql}".replacen("${limit_sql}", &
[INFO] [stdout]             { & arg ["limit_sql"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         } return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_by_permission_or_name(rb : & mut dyn rbatis :: executor :: Executor,
[INFO] [stdout] table_column : & str, table_name : & str, permission : & str, name : & str,)
[INFO] [stdout] -> std :: result :: Result < Vec < SysRes >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("permission".to_string().into(), rbs ::
[INFO] [stdout]     to_value(permission).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(95usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["permission"] }).unwrap_or_default()) ;
[INFO] [stdout]         args.push(rbs :: to_value({ & arg ["name"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} where permission =? or name = ?".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_by_ids(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str, ids : & Vec < String >,) -> std :: result :: Result <
[INFO] [stdout] Vec < SysRes >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("ids".to_string().into(), rbs ::
[INFO] [stdout]     to_value(ids).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(70usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} where id in (".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(0usize) ; for(_, id) in
[INFO] [stdout]             { & arg ["ids"] } {} sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; args.push(rbs :: to_value({ & arg ["id"] }).unwrap_or_default())
[INFO] [stdout]         ; sql.push_str("?,)") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_by_parent_id_null(rb : & mut dyn rbatis :: executor :: Executor,
[INFO] [stdout] table_column : & str, table_name : & str,) -> std :: result :: Result < Vec <
[INFO] [stdout] SysRes >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(95usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} where parent_id IS NULL order by create_date desc".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] insert_batch(rb : & mut dyn rbatis :: executor :: Executor, tables : &
[INFO] [stdout] [SysRole], table_name : & str,) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("tables".to_string().into(), rbs ::
[INFO] [stdout]     to_value(tables).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(65usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("insert into ${table_name} ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(35usize) ; for(idx, table)
[INFO] [stdout]             in { & arg ["tables"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if { (idx).op_eq(& 0i64) }.to_owned().into()
[INFO] [stdout]                 {
[INFO] [stdout]                     sql.push_str("(") ;
[INFO] [stdout]                     sql.push_str(&
[INFO] [stdout]                     {
[INFO] [stdout]                         let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                         { table }
[INFO] [stdout]                         {
[INFO] [stdout]                             if
[INFO] [stdout]                             {
[INFO] [stdout]                                 bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                                 op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                             }.to_owned().into() { continue }
[INFO] [stdout]                             sql.push_str("${k},".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                             1).as_str()) ;
[INFO] [stdout]                         } sql =
[INFO] [stdout]                         sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                         ; sql
[INFO] [stdout]                     }) ; sql.push_str(") VALUES ") ;
[INFO] [stdout]                 } sql.push_str("(") ;
[INFO] [stdout]                 sql.push_str(&
[INFO] [stdout]                 {
[INFO] [stdout]                     let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                     { table }
[INFO] [stdout]                     {
[INFO] [stdout]                         if
[INFO] [stdout]                         {
[INFO] [stdout]                             bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                             op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                         }.to_owned().into() { continue }
[INFO] [stdout]                         args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                         sql.push_str("?,") ;
[INFO] [stdout]                     } sql =
[INFO] [stdout]                     sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                     ; sql
[INFO] [stdout]                 }) ; sql.push_str("),") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_all(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str,) -> std :: result :: Result < Vec < SysRole >, rbatis
[INFO] [stdout] :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(44usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} ".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_value : V,) -> std :: result ::
[INFO] [stdout] Result < Vec < SysRole >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} = ?".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_values : & [V],) -> std :: result
[INFO] [stdout] :: Result < Vec < SysRole >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} in (".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] update_by_column_value(rb : & mut dyn rbatis :: executor :: Executor,
[INFO] [stdout] table_name : String, table : & rbs :: Value, column : & str, column_value :
[INFO] [stdout] & rbs :: Value,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(77usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("update ${table_name} set ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(12usize) ; for(k, v) in
[INFO] [stdout]             { & arg ["table"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if
[INFO] [stdout]                 {
[INFO] [stdout]                     bool :: op_from((k).op_eq(& & arg ["column"])) || bool ::
[INFO] [stdout]                     op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                 }.to_owned().into() { continue }
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("${k}=?,".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                 1).as_str()) ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str(" where ${column} = ?".replacen("${column}", &
[INFO] [stdout]         { & arg ["column"] }.as_sql(), 1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_value : V,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} = ?".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column_batch < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(60usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(7usize) ; for(_, v) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_list_by_ids(rb : & mut dyn rbatis :: executor :: Executor, table_column
[INFO] [stdout] : & str, table_name : & str, ids : & [String],) -> std :: result :: Result <
[INFO] [stdout] Vec < SysRole >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("ids".to_string().into(), rbs ::
[INFO] [stdout]     to_value(ids).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(72usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} where id in (".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(0usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["ids"] } {} sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ;
[INFO] [stdout]         args.push(rbs :: to_value({ & arg ["item"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("?,)") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_page_by_name(rb : & mut dyn rbatis :: executor :: Executor,
[INFO] [stdout] table_column : & str, table_name : & str, name : & str,) -> std :: result ::
[INFO] [stdout] Result < u64, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(143usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select count(1) as count from ${table_name} where del = 0".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(), 1).as_str()) ; if
[INFO] [stdout]         { (& arg ["name"]).op_ne(& "") }.to_owned().into() {}
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({
[INFO] [stdout]             ((String :: from("%")).op_add(& arg ["name"])).op_add(& "%")
[INFO] [stdout]         }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str(" and name like ?and parent_id IS NULL") ; if
[INFO] [stdout]         { ! sql.contains("count") }.to_owned().into() {}
[INFO] [stdout]         sql.push_str("order by create_date desc") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_page_by_name(rb : & mut dyn rbatis :: executor :: Executor,
[INFO] [stdout] table_column : & str, table_name : & str, page_no : u64, page_size : u64,
[INFO] [stdout] page_offset : u64, limit_sql : & str, name : & str,) -> std :: result ::
[INFO] [stdout] Result < Vec < SysRole >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("page_no".to_string().into(), rbs ::
[INFO] [stdout]     to_value(page_no).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("page_size".to_string().into(), rbs ::
[INFO] [stdout]     to_value(page_size).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("page_offset".to_string().into(), rbs ::
[INFO] [stdout]     to_value(page_offset).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("limit_sql".to_string().into(), rbs ::
[INFO] [stdout]     to_value(limit_sql).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(155usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} where del = 0".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; if { (& arg ["name"]).op_ne(& "") }.to_owned().into()
[INFO] [stdout]         {}
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({
[INFO] [stdout]             ((String :: from("%")).op_add(& arg ["name"])).op_add(& "%")
[INFO] [stdout]         }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str(" and name like ?and parent_id IS NULL") ; if
[INFO] [stdout]         { ! sql.contains("count") }.to_owned().into() {}
[INFO] [stdout]         sql.push_str("order by create_date desc") ; if
[INFO] [stdout]         {
[INFO] [stdout]             bool :: op_from(! sql.contains("page_no")) && bool ::
[INFO] [stdout]             op_from(! sql.contains("page_size"))
[INFO] [stdout]         }.to_owned().into()
[INFO] [stdout]         {
[INFO] [stdout]             sql.push_str("${limit_sql}".replacen("${limit_sql}", &
[INFO] [stdout]             { & arg ["limit_sql"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         } return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] insert_batch(rb : & mut dyn rbatis :: executor :: Executor, tables : &
[INFO] [stdout] [SysRoleRes], table_name : & str,) -> std :: result :: Result < rbatis :: rbdc
[INFO] [stdout] :: db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("tables".to_string().into(), rbs ::
[INFO] [stdout]     to_value(tables).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(65usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("insert into ${table_name} ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(35usize) ; for(idx, table)
[INFO] [stdout]             in { & arg ["tables"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if { (idx).op_eq(& 0i64) }.to_owned().into()
[INFO] [stdout]                 {
[INFO] [stdout]                     sql.push_str("(") ;
[INFO] [stdout]                     sql.push_str(&
[INFO] [stdout]                     {
[INFO] [stdout]                         let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                         { table }
[INFO] [stdout]                         {
[INFO] [stdout]                             if
[INFO] [stdout]                             {
[INFO] [stdout]                                 bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                                 op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                             }.to_owned().into() { continue }
[INFO] [stdout]                             sql.push_str("${k},".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                             1).as_str()) ;
[INFO] [stdout]                         } sql =
[INFO] [stdout]                         sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                         ; sql
[INFO] [stdout]                     }) ; sql.push_str(") VALUES ") ;
[INFO] [stdout]                 } sql.push_str("(") ;
[INFO] [stdout]                 sql.push_str(&
[INFO] [stdout]                 {
[INFO] [stdout]                     let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                     { table }
[INFO] [stdout]                     {
[INFO] [stdout]                         if
[INFO] [stdout]                         {
[INFO] [stdout]                             bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                             op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                         }.to_owned().into() { continue }
[INFO] [stdout]                         args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                         sql.push_str("?,") ;
[INFO] [stdout]                     } sql =
[INFO] [stdout]                     sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                     ; sql
[INFO] [stdout]                 }) ; sql.push_str("),") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_all(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str,) -> std :: result :: Result < Vec < SysRoleRes >,
[INFO] [stdout] rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(44usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} ".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_value : V,) -> std :: result ::
[INFO] [stdout] Result < Vec < SysRoleRes >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} = ?".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_values : & [V],) -> std :: result
[INFO] [stdout] :: Result < Vec < SysRoleRes >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} in (".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] update_by_column_value(rb : & mut dyn rbatis :: executor :: Executor,
[INFO] [stdout] table_name : String, table : & rbs :: Value, column : & str, column_value :
[INFO] [stdout] & rbs :: Value,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(77usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("update ${table_name} set ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(12usize) ; for(k, v) in
[INFO] [stdout]             { & arg ["table"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if
[INFO] [stdout]                 {
[INFO] [stdout]                     bool :: op_from((k).op_eq(& & arg ["column"])) || bool ::
[INFO] [stdout]                     op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                 }.to_owned().into() { continue }
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("${k}=?,".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                 1).as_str()) ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str(" where ${column} = ?".replacen("${column}", &
[INFO] [stdout]         { & arg ["column"] }.as_sql(), 1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_value : V,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} = ?".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column_batch < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(60usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(7usize) ; for(_, v) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_by_role_id(rb : & mut dyn rbatis :: executor :: Executor, table_column
[INFO] [stdout] : & str, table_name : & str, role_ids : & [String],) -> std :: result ::
[INFO] [stdout] Result < Vec < SysRoleRes >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("role_ids".to_string().into(), rbs ::
[INFO] [stdout]     to_value(role_ids).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(77usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} where role_id in (".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(0usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["role_ids"] } {} sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ;
[INFO] [stdout]         args.push(rbs :: to_value({ & arg ["item"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("?,)") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] insert_batch(rb : & mut dyn rbatis :: executor :: Executor, tables : &
[INFO] [stdout] [SysUser], table_name : & str,) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("tables".to_string().into(), rbs ::
[INFO] [stdout]     to_value(tables).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(65usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("insert into ${table_name} ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(35usize) ; for(idx, table)
[INFO] [stdout]             in { & arg ["tables"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if { (idx).op_eq(& 0i64) }.to_owned().into()
[INFO] [stdout]                 {
[INFO] [stdout]                     sql.push_str("(") ;
[INFO] [stdout]                     sql.push_str(&
[INFO] [stdout]                     {
[INFO] [stdout]                         let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                         { table }
[INFO] [stdout]                         {
[INFO] [stdout]                             if
[INFO] [stdout]                             {
[INFO] [stdout]                                 bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                                 op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                             }.to_owned().into() { continue }
[INFO] [stdout]                             sql.push_str("${k},".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                             1).as_str()) ;
[INFO] [stdout]                         } sql =
[INFO] [stdout]                         sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                         ; sql
[INFO] [stdout]                     }) ; sql.push_str(") VALUES ") ;
[INFO] [stdout]                 } sql.push_str("(") ;
[INFO] [stdout]                 sql.push_str(&
[INFO] [stdout]                 {
[INFO] [stdout]                     let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                     { table }
[INFO] [stdout]                     {
[INFO] [stdout]                         if
[INFO] [stdout]                         {
[INFO] [stdout]                             bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                             op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                         }.to_owned().into() { continue }
[INFO] [stdout]                         args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                         sql.push_str("?,") ;
[INFO] [stdout]                     } sql =
[INFO] [stdout]                     sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                     ; sql
[INFO] [stdout]                 }) ; sql.push_str("),") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_all(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str,) -> std :: result :: Result < Vec < SysUser >, rbatis
[INFO] [stdout] :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(44usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} ".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_value : V,) -> std :: result ::
[INFO] [stdout] Result < Vec < SysUser >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} = ?".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_values : & [V],) -> std :: result
[INFO] [stdout] :: Result < Vec < SysUser >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} in (".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] update_by_column_value(rb : & mut dyn rbatis :: executor :: Executor,
[INFO] [stdout] table_name : String, table : & rbs :: Value, column : & str, column_value :
[INFO] [stdout] & rbs :: Value,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(77usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("update ${table_name} set ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(12usize) ; for(k, v) in
[INFO] [stdout]             { & arg ["table"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if
[INFO] [stdout]                 {
[INFO] [stdout]                     bool :: op_from((k).op_eq(& & arg ["column"])) || bool ::
[INFO] [stdout]                     op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                 }.to_owned().into() { continue }
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("${k}=?,".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                 1).as_str()) ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str(" where ${column} = ?".replacen("${column}", &
[INFO] [stdout]         { & arg ["column"] }.as_sql(), 1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_value : V,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} = ?".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column_batch < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(60usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(7usize) ; for(_, v) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_page(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str, name : & str, account : & str,) -> std :: result ::
[INFO] [stdout] Result < u64, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("account".to_string().into(), rbs ::
[INFO] [stdout]     to_value(account).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(159usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select count(1) as count from ${table_name} where del=0".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(), 1).as_str()) ; if
[INFO] [stdout]         { (& arg ["name"]).op_ne(& "") }.to_owned().into() {}
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({
[INFO] [stdout]             ((String :: from("%")).op_add(& arg ["name"])).op_add(& "%")
[INFO] [stdout]         }).unwrap_or_default()) ; sql.push_str(" and name like ?") ; if
[INFO] [stdout]         { (& arg ["account"]).op_ne(& "") }.to_owned().into() {}
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({
[INFO] [stdout]             ((String :: from("%")).op_add(& arg ["account"])).op_add(& "%")
[INFO] [stdout]         }).unwrap_or_default()) ; sql.push_str(" and account like ?") ; if
[INFO] [stdout]         { ! sql.contains("count") }.to_owned().into() {}
[INFO] [stdout]         sql.push_str("order by create data desc") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_page(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str, page_no : u64, page_size : u64, page_offset : u64,
[INFO] [stdout] limit_sql : & str, name : & str, account : & str,) -> std :: result :: Result
[INFO] [stdout] < Vec < SysUser >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("page_no".to_string().into(), rbs ::
[INFO] [stdout]     to_value(page_no).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("page_size".to_string().into(), rbs ::
[INFO] [stdout]     to_value(page_size).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("page_offset".to_string().into(), rbs ::
[INFO] [stdout]     to_value(page_offset).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("limit_sql".to_string().into(), rbs ::
[INFO] [stdout]     to_value(limit_sql).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("account".to_string().into(), rbs ::
[INFO] [stdout]     to_value(account).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(171usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} where del=0".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; if { (& arg ["name"]).op_ne(& "") }.to_owned().into()
[INFO] [stdout]         {}
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({
[INFO] [stdout]             ((String :: from("%")).op_add(& arg ["name"])).op_add(& "%")
[INFO] [stdout]         }).unwrap_or_default()) ; sql.push_str(" and name like ?") ; if
[INFO] [stdout]         { (& arg ["account"]).op_ne(& "") }.to_owned().into() {}
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({
[INFO] [stdout]             ((String :: from("%")).op_add(& arg ["account"])).op_add(& "%")
[INFO] [stdout]         }).unwrap_or_default()) ; sql.push_str(" and account like ?") ; if
[INFO] [stdout]         { ! sql.contains("count") }.to_owned().into() {}
[INFO] [stdout]         sql.push_str("order by create data desc") ; if
[INFO] [stdout]         {
[INFO] [stdout]             bool :: op_from(! sql.contains("page_no")) && bool ::
[INFO] [stdout]             op_from(! sql.contains("page_size"))
[INFO] [stdout]         }.to_owned().into()
[INFO] [stdout]         {
[INFO] [stdout]             sql.push_str("${limit_sql}".replacen("${limit_sql}", &
[INFO] [stdout]             { & arg ["limit_sql"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         } return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] insert_batch(rb : & mut dyn rbatis :: executor :: Executor, tables : &
[INFO] [stdout] [SysUserRole], table_name : & str,) -> std :: result :: Result < rbatis ::
[INFO] [stdout] rbdc :: db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("tables".to_string().into(), rbs ::
[INFO] [stdout]     to_value(tables).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(65usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("insert into ${table_name} ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(35usize) ; for(idx, table)
[INFO] [stdout]             in { & arg ["tables"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if { (idx).op_eq(& 0i64) }.to_owned().into()
[INFO] [stdout]                 {
[INFO] [stdout]                     sql.push_str("(") ;
[INFO] [stdout]                     sql.push_str(&
[INFO] [stdout]                     {
[INFO] [stdout]                         let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                         { table }
[INFO] [stdout]                         {
[INFO] [stdout]                             if
[INFO] [stdout]                             {
[INFO] [stdout]                                 bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                                 op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                             }.to_owned().into() { continue }
[INFO] [stdout]                             sql.push_str("${k},".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                             1).as_str()) ;
[INFO] [stdout]                         } sql =
[INFO] [stdout]                         sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                         ; sql
[INFO] [stdout]                     }) ; sql.push_str(") VALUES ") ;
[INFO] [stdout]                 } sql.push_str("(") ;
[INFO] [stdout]                 sql.push_str(&
[INFO] [stdout]                 {
[INFO] [stdout]                     let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                     { table }
[INFO] [stdout]                     {
[INFO] [stdout]                         if
[INFO] [stdout]                         {
[INFO] [stdout]                             bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                             op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                         }.to_owned().into() { continue }
[INFO] [stdout]                         args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                         sql.push_str("?,") ;
[INFO] [stdout]                     } sql =
[INFO] [stdout]                     sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                     ; sql
[INFO] [stdout]                 }) ; sql.push_str("),") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_all(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str,) -> std :: result :: Result < Vec < SysUserRole >,
[INFO] [stdout] rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(44usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} ".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_value : V,) -> std :: result ::
[INFO] [stdout] Result < Vec < SysUserRole >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} = ?".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_values : & [V],) -> std :: result
[INFO] [stdout] :: Result < Vec < SysUserRole >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} in (".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] update_by_column_value(rb : & mut dyn rbatis :: executor :: Executor,
[INFO] [stdout] table_name : String, table : & rbs :: Value, column : & str, column_value :
[INFO] [stdout] & rbs :: Value,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(77usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("update ${table_name} set ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(12usize) ; for(k, v) in
[INFO] [stdout]             { & arg ["table"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if
[INFO] [stdout]                 {
[INFO] [stdout]                     bool :: op_from((k).op_eq(& & arg ["column"])) || bool ::
[INFO] [stdout]                     op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                 }.to_owned().into() { continue }
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("${k}=?,".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                 1).as_str()) ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str(" where ${column} = ?".replacen("${column}", &
[INFO] [stdout]         { & arg ["column"] }.as_sql(), 1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_value : V,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} = ?".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column_batch < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(60usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(7usize) ; for(_, v) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_list_in_user_id(rb : & mut dyn rbatis :: executor :: Executor,
[INFO] [stdout] table_column : & str, table_name : & str, user_ids : & [String],) -> std ::
[INFO] [stdout] result :: Result < Vec < SysUserRole >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("user_ids".to_string().into(), rbs ::
[INFO] [stdout]     to_value(user_ids).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(74usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} where user_id in (".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(0usize) ; for(_, v) in
[INFO] [stdout]             { & arg ["user_ids"] } {} sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; args.push(rbs :: to_value({ & arg ["v"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("?,)") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] insert_batch(rb : & mut dyn rbatis :: executor :: Executor, tables : &
[INFO] [stdout] [SysTrash], table_name : & str,) -> std :: result :: Result < rbatis :: rbdc
[INFO] [stdout] :: db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("tables".to_string().into(), rbs ::
[INFO] [stdout]     to_value(tables).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(65usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("insert into ${table_name} ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(35usize) ; for(idx, table)
[INFO] [stdout]             in { & arg ["tables"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if { (idx).op_eq(& 0i64) }.to_owned().into()
[INFO] [stdout]                 {
[INFO] [stdout]                     sql.push_str("(") ;
[INFO] [stdout]                     sql.push_str(&
[INFO] [stdout]                     {
[INFO] [stdout]                         let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                         { table }
[INFO] [stdout]                         {
[INFO] [stdout]                             if
[INFO] [stdout]                             {
[INFO] [stdout]                                 bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                                 op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                             }.to_owned().into() { continue }
[INFO] [stdout]                             sql.push_str("${k},".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                             1).as_str()) ;
[INFO] [stdout]                         } sql =
[INFO] [stdout]                         sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                         ; sql
[INFO] [stdout]                     }) ; sql.push_str(") VALUES ") ;
[INFO] [stdout]                 } sql.push_str("(") ;
[INFO] [stdout]                 sql.push_str(&
[INFO] [stdout]                 {
[INFO] [stdout]                     let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                     { table }
[INFO] [stdout]                     {
[INFO] [stdout]                         if
[INFO] [stdout]                         {
[INFO] [stdout]                             bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                             op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                         }.to_owned().into() { continue }
[INFO] [stdout]                         args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                         sql.push_str("?,") ;
[INFO] [stdout]                     } sql =
[INFO] [stdout]                     sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                     ; sql
[INFO] [stdout]                 }) ; sql.push_str("),") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_all(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str,) -> std :: result :: Result < Vec < SysTrash >,
[INFO] [stdout] rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(44usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} ".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_value : V,) -> std :: result ::
[INFO] [stdout] Result < Vec < SysTrash >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} = ?".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_values : & [V],) -> std :: result
[INFO] [stdout] :: Result < Vec < SysTrash >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} in (".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] update_by_column_value(rb : & mut dyn rbatis :: executor :: Executor,
[INFO] [stdout] table_name : String, table : & rbs :: Value, column : & str, column_value :
[INFO] [stdout] & rbs :: Value,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(77usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("update ${table_name} set ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(12usize) ; for(k, v) in
[INFO] [stdout]             { & arg ["table"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if
[INFO] [stdout]                 {
[INFO] [stdout]                     bool :: op_from((k).op_eq(& & arg ["column"])) || bool ::
[INFO] [stdout]                     op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                 }.to_owned().into() { continue }
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("${k}=?,".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                 1).as_str()) ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str(" where ${column} = ?".replacen("${column}", &
[INFO] [stdout]         { & arg ["column"] }.as_sql(), 1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_value : V,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} = ?".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column_batch < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(60usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(7usize) ; for(_, v) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] insert_batch(rb : & mut dyn rbatis :: executor :: Executor, tables : &
[INFO] [stdout] [SysDict], table_name : & str,) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("tables".to_string().into(), rbs ::
[INFO] [stdout]     to_value(tables).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(65usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("insert into ${table_name} ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(35usize) ; for(idx, table)
[INFO] [stdout]             in { & arg ["tables"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if { (idx).op_eq(& 0i64) }.to_owned().into()
[INFO] [stdout]                 {
[INFO] [stdout]                     sql.push_str("(") ;
[INFO] [stdout]                     sql.push_str(&
[INFO] [stdout]                     {
[INFO] [stdout]                         let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                         { table }
[INFO] [stdout]                         {
[INFO] [stdout]                             if
[INFO] [stdout]                             {
[INFO] [stdout]                                 bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                                 op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                             }.to_owned().into() { continue }
[INFO] [stdout]                             sql.push_str("${k},".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                             1).as_str()) ;
[INFO] [stdout]                         } sql =
[INFO] [stdout]                         sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                         ; sql
[INFO] [stdout]                     }) ; sql.push_str(") VALUES ") ;
[INFO] [stdout]                 } sql.push_str("(") ;
[INFO] [stdout]                 sql.push_str(&
[INFO] [stdout]                 {
[INFO] [stdout]                     let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                     { table }
[INFO] [stdout]                     {
[INFO] [stdout]                         if
[INFO] [stdout]                         {
[INFO] [stdout]                             bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                             op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                         }.to_owned().into() { continue }
[INFO] [stdout]                         args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                         sql.push_str("?,") ;
[INFO] [stdout]                     } sql =
[INFO] [stdout]                     sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                     ; sql
[INFO] [stdout]                 }) ; sql.push_str("),") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_all(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str,) -> std :: result :: Result < Vec < SysDict >, rbatis
[INFO] [stdout] :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(44usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} ".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_value : V,) -> std :: result ::
[INFO] [stdout] Result < Vec < SysDict >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} = ?".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_values : & [V],) -> std :: result
[INFO] [stdout] :: Result < Vec < SysDict >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} in (".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] update_by_column_value(rb : & mut dyn rbatis :: executor :: Executor,
[INFO] [stdout] table_name : String, table : & rbs :: Value, column : & str, column_value :
[INFO] [stdout] & rbs :: Value,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(77usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("update ${table_name} set ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(12usize) ; for(k, v) in
[INFO] [stdout]             { & arg ["table"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if
[INFO] [stdout]                 {
[INFO] [stdout]                     bool :: op_from((k).op_eq(& & arg ["column"])) || bool ::
[INFO] [stdout]                     op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                 }.to_owned().into() { continue }
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("${k}=?,".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                 1).as_str()) ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str(" where ${column} = ?".replacen("${column}", &
[INFO] [stdout]         { & arg ["column"] }.as_sql(), 1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_value : V,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} = ?".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column_batch < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(60usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(7usize) ; for(_, v) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_page(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str, dto : & DictPageDTO,) -> std :: result :: Result <
[INFO] [stdout] u64, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("dto".to_string().into(), rbs ::
[INFO] [stdout]     to_value(dto).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(132usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select count(1) as count from ${table_name} where id!=''".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(), 1).as_str()) ; if
[INFO] [stdout]         {
[INFO] [stdout]             ((& arg ["dto"] ["code"])).op_ne(& rbs :: Value :: Null)
[INFO] [stdout]         }.to_owned().into()
[INFO] [stdout]         {
[INFO] [stdout]             args.push(rbs ::
[INFO] [stdout]             to_value({ (& arg ["dto"] ["code"]) }).unwrap_or_default()) ;
[INFO] [stdout]             sql.push_str(" and code = ?") ;
[INFO] [stdout]         } if
[INFO] [stdout]         {
[INFO] [stdout]             ((& arg ["dto"] ["name"])).op_ne(& rbs :: Value :: Null)
[INFO] [stdout]         }.to_owned().into()
[INFO] [stdout]         {
[INFO] [stdout]             args.push(rbs ::
[INFO] [stdout]             to_value({ (& arg ["dto"] ["name"]) }).unwrap_or_default()) ;
[INFO] [stdout]             sql.push_str(" and name = ?") ;
[INFO] [stdout]         } if { ! sql.contains("count") }.to_owned().into() {}
[INFO] [stdout]         sql.push_str("order by create data") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_page(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str, page_no : u64, page_size : u64, page_offset : u64,
[INFO] [stdout] limit_sql : & str, dto : & DictPageDTO,) -> std :: result :: Result < Vec <
[INFO] [stdout] SysDict >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("page_no".to_string().into(), rbs ::
[INFO] [stdout]     to_value(page_no).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("page_size".to_string().into(), rbs ::
[INFO] [stdout]     to_value(page_size).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("page_offset".to_string().into(), rbs ::
[INFO] [stdout]     to_value(page_offset).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("limit_sql".to_string().into(), rbs ::
[INFO] [stdout]     to_value(limit_sql).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("dto".to_string().into(), rbs ::
[INFO] [stdout]     to_value(dto).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(144usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} where id!=''".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; if
[INFO] [stdout]         {
[INFO] [stdout]             ((& arg ["dto"] ["code"])).op_ne(& rbs :: Value :: Null)
[INFO] [stdout]         }.to_owned().into()
[INFO] [stdout]         {
[INFO] [stdout]             args.push(rbs ::
[INFO] [stdout]             to_value({ (& arg ["dto"] ["code"]) }).unwrap_or_default()) ;
[INFO] [stdout]             sql.push_str(" and code = ?") ;
[INFO] [stdout]         } if
[INFO] [stdout]         {
[INFO] [stdout]             ((& arg ["dto"] ["name"])).op_ne(& rbs :: Value :: Null)
[INFO] [stdout]         }.to_owned().into()
[INFO] [stdout]         {
[INFO] [stdout]             args.push(rbs ::
[INFO] [stdout]             to_value({ (& arg ["dto"] ["name"]) }).unwrap_or_default()) ;
[INFO] [stdout]             sql.push_str(" and name = ?") ;
[INFO] [stdout]         } if { ! sql.contains("count") }.to_owned().into() {}
[INFO] [stdout]         sql.push_str("order by create data") ; if
[INFO] [stdout]         {
[INFO] [stdout]             bool :: op_from(! sql.contains("page_no")) && bool ::
[INFO] [stdout]             op_from(! sql.contains("page_size"))
[INFO] [stdout]         }.to_owned().into()
[INFO] [stdout]         {
[INFO] [stdout]             sql.push_str("${limit_sql}".replacen("${limit_sql}", &
[INFO] [stdout]             { & arg ["limit_sql"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         } return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] warning: trait `isEmptyString` should have an upper camel case name
[INFO] [stdout]  --> src/util/string.rs:1:11
[INFO] [stdout]   |
[INFO] [stdout] 1 | pub trait isEmptyString {
[INFO] [stdout]   |           ^^^^^^^^^^^^^ help: convert the identifier to upper camel case (notice the capitalization): `IsEmptyString`
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(non_camel_case_types)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]   --> src/controller/img_verify_controller.rs:12:5
[INFO] [stdout]    |
[INFO] [stdout] 12 |       /// 账户为空时，不输出验证码，并且报错
[INFO] [stdout]    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 13 | /     if arg.account.is_empty() {
[INFO] [stdout] 14 | |         return RespVO::<()>::from_error(&Error::from("account is empty"), "-1").resp_json();
[INFO] [stdout] 15 | |     }
[INFO] [stdout]    | |_____- rustdoc does not generate documentation for expressions
[INFO] [stdout]    |
[INFO] [stdout]    = help: use `//` for a plain comment
[INFO] [stdout]    = note: `#[warn(unused_doc_comments)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::error::Error`
[INFO] [stdout]  --> src/controller/sys_role_controller.rs:6:5
[INFO] [stdout]   |
[INFO] [stdout] 6 | use crate::error::Error;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]   --> src/service/sys_user_service.rs:51:9
[INFO] [stdout]    |
[INFO] [stdout] 51 |           /// 防止爆破登录
[INFO] [stdout]    |           ^^^^^^^^^^^^^^^^
[INFO] [stdout] 52 |           // println!("sign in {:?}", arg);
[INFO] [stdout] 53 | /         let user = SysUser::select_by_column(pool!(), field_name!(SysUser.account), &arg.account)
[INFO] [stdout] 54 | |             .await?
[INFO] [stdout] 55 | |             .into_iter()
[INFO] [stdout] 56 | |             .next();
[INFO] [stdout]    | |____________________- rustdoc does not generate documentation for statements
[INFO] [stdout]    |
[INFO] [stdout]    = help: use `//` for a plain comment
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]    --> src/service/sys_user_service.rs:101:13
[INFO] [stdout]     |
[INFO] [stdout] 101 |             /// 增加重试次数
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^
[INFO] [stdout] 102 |             return Err(error.unwrap());
[INFO] [stdout]     |             -------------------------- rustdoc does not generate documentation for expressions
[INFO] [stdout]     |
[INFO] [stdout]     = help: use `//` for a plain comment
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]    --> src/service/sys_user_service.rs:118:9
[INFO] [stdout]     |
[INFO] [stdout] 118 |         /// 去除密码
[INFO] [stdout]     |         ^^^^^^^^^^^^
[INFO] [stdout] 119 |         let mut user = user.clone();
[INFO] [stdout]     |         ---------------------------- rustdoc does not generate documentation for statements
[INFO] [stdout]     |
[INFO] [stdout]     = help: use `//` for a plain comment
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]    --> src/service/sys_user_service.rs:121:9
[INFO] [stdout]     |
[INFO] [stdout] 121 |           /// 拿到ID
[INFO] [stdout]     |           ^^^^^^^^^^
[INFO] [stdout] 122 | /         let user_id = user
[INFO] [stdout] 123 | |             .id
[INFO] [stdout] 124 | |             .clone()
[INFO] [stdout] 125 | |             .ok_or_else(|| Error::from("用户数据错误，id为空"))?;
[INFO] [stdout]     | |_________________________________________________________________- rustdoc does not generate documentation for statements
[INFO] [stdout]     |
[INFO] [stdout]     = help: use `//` for a plain comment
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]    --> src/service/sys_user_service.rs:253:9
[INFO] [stdout]     |
[INFO] [stdout] 253 | /         /// 记录删除日志
[INFO] [stdout] 254 | |         /// 删除对应用户的角色
[INFO] [stdout]     | |______________________________^
[INFO] [stdout] 255 |           CONTEXT.sys_user_role_service.remove_by_user_id(id).await?;
[INFO] [stdout]     |           ---------------------------------------------------------- rustdoc does not generate documentation for expressions
[INFO] [stdout]     |
[INFO] [stdout]     = help: use `//` for a plain comment
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::domain::table::SysRole`
[INFO] [stdout]  --> src/service/sys_user_role_service.rs:7:5
[INFO] [stdout]   |
[INFO] [stdout] 7 | use crate::domain::table::SysRole;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]   --> src/service/sys_user_role_service.rs:44:9
[INFO] [stdout]    |
[INFO] [stdout] 44 |         /// 形成角色
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 45 |         let mut user_role = SysUserRole::from(arg);
[INFO] [stdout]    |         ------------------------------------------- rustdoc does not generate documentation for statements
[INFO] [stdout]    |
[INFO] [stdout]    = help: use `//` for a plain comment
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `actix_web::guard`
[INFO] [stdout]  --> src/service/mem_service.rs:1:5
[INFO] [stdout]   |
[INFO] [stdout] 1 | use actix_web::guard;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `res`
[INFO] [stdout]  --> src/service/sys_role_service.rs:8:13
[INFO] [stdout]   |
[INFO] [stdout] 8 |             res,
[INFO] [stdout]   |             ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary parentheses around type
[INFO] [stdout]    --> src/service/sys_role_service.rs:139:52
[INFO] [stdout]     |
[INFO] [stdout] 139 |     pub async fn remove(&self, id: &str) -> Result<(u64)> {
[INFO] [stdout]     |                                                    ^   ^
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(unused_parens)]` on by default
[INFO] [stdout] help: remove these parentheses
[INFO] [stdout]     |
[INFO] [stdout] 139 -     pub async fn remove(&self, id: &str) -> Result<(u64)> {
[INFO] [stdout] 139 +     pub async fn remove(&self, id: &str) -> Result<u64> {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `sys_role_service::SysRoleService`
[INFO] [stdout]   --> src/service/sys_res_service.rs:15:13
[INFO] [stdout]    |
[INFO] [stdout] 15 | use super::{sys_role_service::SysRoleService, CONTEXT};
[INFO] [stdout]    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]    --> src/service/sys_res_service.rs:102:9
[INFO] [stdout]     |
[INFO] [stdout] 102 |         /// 之后可以添加代码实现打印日志
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 103 |         let mut arr = vec![];
[INFO] [stdout]     |         --------------------- rustdoc does not generate documentation for statements
[INFO] [stdout]     |
[INFO] [stdout]     = help: use `//` for a plain comment
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]   --> src/service/sys_dict_service.rs:47:9
[INFO] [stdout]    |
[INFO] [stdout] 47 | /         /// 以后逻辑可能会改
[INFO] [stdout] 48 | |         ///
[INFO] [stdout]    | |___________^
[INFO] [stdout] 49 |           let res = SysDict::update_by_column(pool!(), &data, "id").await?;
[INFO] [stdout]    |           ----------------------------------------------------------------- rustdoc does not generate documentation for statements
[INFO] [stdout]    |
[INFO] [stdout]    = help: use `//` for a plain comment
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `super::*`
[INFO] [stdout]    --> src/service/mod.rs:141:9
[INFO] [stdout]     |
[INFO] [stdout] 141 |     use super::*;
[INFO] [stdout]     |         ^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `serde::de::Visitor`
[INFO] [stdout]  --> src/error.rs:6:5
[INFO] [stdout]   |
[INFO] [stdout] 6 | use serde::de::Visitor;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused imports: `Serialize`, `Serializer`
[INFO] [stdout]  --> src/error.rs:7:18
[INFO] [stdout]   |
[INFO] [stdout] 7 | use serde::ser::{Serialize, Serializer};
[INFO] [stdout]   |                  ^^^^^^^^^  ^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused imports: `Deserialize`, `Deserializer`
[INFO] [stdout]  --> src/error.rs:8:13
[INFO] [stdout]   |
[INFO] [stdout] 8 | use serde::{Deserialize, Deserializer};
[INFO] [stdout]   |             ^^^^^^^^^^^  ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `rbatis::object_id::ObjectId`
[INFO] [stdout]  --> src/domain/dto/user.rs:1:5
[INFO] [stdout]   |
[INFO] [stdout] 1 | use rbatis::object_id::ObjectId;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::util::password_encoder::PasswordEncoder`
[INFO] [stdout]  --> src/domain/dto/user.rs:9:5
[INFO] [stdout]   |
[INFO] [stdout] 9 | use crate::util::password_encoder::PasswordEncoder;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: type `JWT_Token` should have an upper camel case name
[INFO] [stdout]  --> src/domain/vo/jwt.rs:9:12
[INFO] [stdout]   |
[INFO] [stdout] 9 | pub struct JWT_Token {
[INFO] [stdout]   |            ^^^^^^^^^ help: convert the identifier to upper camel case: `JwtToken`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]  --> src/domain/mapper/sys_user.rs:3:1
[INFO] [stdout]   |
[INFO] [stdout] 3 | / /// 后台用户表 过程宏
[INFO] [stdout] 4 | | /// 只有使用了crud！ 这个宏之后，才能生成之后的宏
[INFO] [stdout]   | |_------------------------------------------------^
[INFO] [stdout]   |   |
[INFO] [stdout]   |   rustdoc does not generate documentation for macro invocations
[INFO] [stdout]   |
[INFO] [stdout]   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]  --> src/domain/mapper/sys_user_role.rs:3:1
[INFO] [stdout]   |
[INFO] [stdout] 3 | / /// 后台用户角色表 过程宏
[INFO] [stdout] 4 | | /// 只有使用了crud！ 这个宏之后，才能生成之后的宏
[INFO] [stdout]   | |_------------------------------------------------^
[INFO] [stdout]   |   |
[INFO] [stdout]   |   rustdoc does not generate documentation for macro invocations
[INFO] [stdout]   |
[INFO] [stdout]   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]  --> src/domain/mapper/sys_dict.rs:4:1
[INFO] [stdout]   |
[INFO] [stdout] 4 | / /// 系统字典表 过程宏
[INFO] [stdout] 5 | | /// 只有使用了crud！ 这个宏之后，才能生成之后的宏
[INFO] [stdout]   | |_------------------------------------------------^
[INFO] [stdout]   |   |
[INFO] [stdout]   |   rustdoc does not generate documentation for macro invocations
[INFO] [stdout]   |
[INFO] [stdout]   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::domain::table::enums::LoginCheck`
[INFO] [stdout]    --> src/domain/table/tables.rs:103:9
[INFO] [stdout]     |
[INFO] [stdout] 103 |     use crate::domain::table::enums::LoginCheck;
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `super::*`
[INFO] [stdout]    --> src/domain/table/tables.rs:105:9
[INFO] [stdout]     |
[INFO] [stdout] 105 |     use super::*;
[INFO] [stdout]     |         ^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::service::CONTEXT`
[INFO] [stdout]   --> src/middleware/auth_actix.rs:13:5
[INFO] [stdout]    |
[INFO] [stdout] 13 | use crate::service::CONTEXT;
[INFO] [stdout]    |     ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]   --> src/service/sys_user_role_service.rs:24:13
[INFO] [stdout]    |
[INFO] [stdout] 24 |         let mut vo = CONTEXT
[INFO] [stdout]    |             ----^^
[INFO] [stdout]    |             |
[INFO] [stdout]    |             help: remove this `mut`
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(unused_mut)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]    --> src/service/sys_role_service.rs:128:13
[INFO] [stdout]     |
[INFO] [stdout] 128 |         let mut role = SysRole::from(arg);
[INFO] [stdout]     |             ----^^^^
[INFO] [stdout]     |             |
[INFO] [stdout]     |             help: remove this `mut`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]   --> src/controller/sys_dict_controller.rs:41:21
[INFO] [stdout]    |
[INFO] [stdout] 41 | pub async fn update(mut arg: web::Json<DictEditDTO>) -> impl Responder {
[INFO] [stdout]    |                     ----^^^
[INFO] [stdout]    |                     |
[INFO] [stdout]    |                     help: remove this `mut`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]   --> src/controller/sys_dict_controller.rs:49:21
[INFO] [stdout]    |
[INFO] [stdout] 49 | pub async fn remove(mut arg: web::Json<IdDTO>) -> impl Responder {
[INFO] [stdout]    |                     ----^^^
[INFO] [stdout]    |                     |
[INFO] [stdout]    |                     help: remove this `mut`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unreachable pattern
[INFO] [stdout]   --> src/service/sys_sms_service.rs:40:13
[INFO] [stdout]    |
[INFO] [stdout] 39 |             _ => Err(Error::from("请发送验证码")),
[INFO] [stdout]    |             - matches any value
[INFO] [stdout] 40 |             Some(v) => {
[INFO] [stdout]    |             ^^^^^^^ unreachable pattern
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(unreachable_patterns)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unreachable pattern
[INFO] [stdout]   --> src/domain/vo/role.rs:41:13
[INFO] [stdout]    |
[INFO] [stdout] 40 |             _ => None,
[INFO] [stdout]    |             - matches any value
[INFO] [stdout] 41 |             Some(arg) => Some(SysRoleVO {
[INFO] [stdout]    |             ^^^^^^^^^ unreachable pattern
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `interimVO` should have a snake case name
[INFO] [stdout]    --> src/service/sys_user_service.rs:126:17
[INFO] [stdout]     |
[INFO] [stdout] 126 |         let mut interimVO = SignVO {
[INFO] [stdout]     |                 ^^^^^^^^^ help: convert the identifier to snake case: `interim_vo`
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(non_snake_case)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: 36 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]     Finished dev [unoptimized + debuginfo] target(s) in 2m 42s
[INFO] [stderr] warning: the following packages contain code that will be rejected by a future version of Rust: rustc-serialize v0.3.24
[INFO] [stderr] note: to see what the problems were, use the option `--future-incompat-report`, or run `cargo report future-incompatibilities --id 4`
[INFO] running `Command { std: "docker" "inspect" "0a19490145e1416d7025952be1ae1d23d3ad3c960bec99049c3d3969f90aec12", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "0a19490145e1416d7025952be1ae1d23d3ad3c960bec99049c3d3969f90aec12", kill_on_drop: false }`
[INFO] [stdout] 0a19490145e1416d7025952be1ae1d23d3ad3c960bec99049c3d3969f90aec12
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=warn" "-e" "RUSTDOCFLAGS=--cap-lints=warn" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:2788e3201cd34a07e3172128adcd8b3090168a8e3bcc40d7c032b9dda1df7d1c" "/opt/rustwide/cargo-home/bin/cargo" "+1.75.0" "test" "--frozen" "--no-run" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] 3777ae4e3f55be3efe2d88d9efb31658ee474de4dc313c8d8bdf4161e2d1f1a8
[INFO] running `Command { std: "docker" "start" "-a" "3777ae4e3f55be3efe2d88d9efb31658ee474de4dc313c8d8bdf4161e2d1f1a8", kill_on_drop: false }`
[INFO] [stdout] warning: trait `isEmptyString` should have an upper camel case name
[INFO] [stdout]  --> src/util/string.rs:1:11
[INFO] [stdout]   |
[INFO] [stdout] 1 | pub trait isEmptyString {
[INFO] [stdout]   |           ^^^^^^^^^^^^^ help: convert the identifier to upper camel case (notice the capitalization): `IsEmptyString`
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(non_camel_case_types)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]   --> src/controller/img_verify_controller.rs:12:5
[INFO] [stdout]    |
[INFO] [stdout] 12 |       /// 账户为空时，不输出验证码，并且报错
[INFO] [stdout]    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 13 | /     if arg.account.is_empty() {
[INFO] [stdout] 14 | |         return RespVO::<()>::from_error(&Error::from("account is empty"), "-1").resp_json();
[INFO] [stdout] 15 | |     }
[INFO] [stdout]    | |_____- rustdoc does not generate documentation for expressions
[INFO] [stdout]    |
[INFO] [stdout]    = help: use `//` for a plain comment
[INFO] [stdout]    = note: `#[warn(unused_doc_comments)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::error::Error`
[INFO] [stdout]  --> src/controller/sys_role_controller.rs:6:5
[INFO] [stdout]   |
[INFO] [stdout] 6 | use crate::error::Error;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]   --> src/service/sys_user_service.rs:51:9
[INFO] [stdout]    |
[INFO] [stdout] 51 |           /// 防止爆破登录
[INFO] [stdout]    |           ^^^^^^^^^^^^^^^^
[INFO] [stdout] 52 |           // println!("sign in {:?}", arg);
[INFO] [stdout] 53 | /         let user = SysUser::select_by_column(pool!(), field_name!(SysUser.account), &arg.account)
[INFO] [stdout] 54 | |             .await?
[INFO] [stdout] 55 | |             .into_iter()
[INFO] [stdout] 56 | |             .next();
[INFO] [stdout]    | |____________________- rustdoc does not generate documentation for statements
[INFO] [stdout]    |
[INFO] [stdout]    = help: use `//` for a plain comment
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]    --> src/service/sys_user_service.rs:101:13
[INFO] [stdout]     |
[INFO] [stdout] 101 |             /// 增加重试次数
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^
[INFO] [stdout] 102 |             return Err(error.unwrap());
[INFO] [stdout]     |             -------------------------- rustdoc does not generate documentation for expressions
[INFO] [stdout]     |
[INFO] [stdout]     = help: use `//` for a plain comment
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]    --> src/service/sys_user_service.rs:118:9
[INFO] [stdout]     |
[INFO] [stdout] 118 |         /// 去除密码
[INFO] [stdout]     |         ^^^^^^^^^^^^
[INFO] [stdout] 119 |         let mut user = user.clone();
[INFO] [stdout]     |         ---------------------------- rustdoc does not generate documentation for statements
[INFO] [stdout]     |
[INFO] [stdout]     = help: use `//` for a plain comment
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]    --> src/service/sys_user_service.rs:121:9
[INFO] [stdout]     |
[INFO] [stdout] 121 |           /// 拿到ID
[INFO] [stdout]     |           ^^^^^^^^^^
[INFO] [stdout] 122 | /         let user_id = user
[INFO] [stdout] 123 | |             .id
[INFO] [stdout] 124 | |             .clone()
[INFO] [stdout] 125 | |             .ok_or_else(|| Error::from("用户数据错误，id为空"))?;
[INFO] [stdout]     | |_________________________________________________________________- rustdoc does not generate documentation for statements
[INFO] [stdout]     |
[INFO] [stdout]     = help: use `//` for a plain comment
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]    --> src/service/sys_user_service.rs:253:9
[INFO] [stdout]     |
[INFO] [stdout] 253 | /         /// 记录删除日志
[INFO] [stdout] 254 | |         /// 删除对应用户的角色
[INFO] [stdout]     | |______________________________^
[INFO] [stdout] 255 |           CONTEXT.sys_user_role_service.remove_by_user_id(id).await?;
[INFO] [stdout]     |           ---------------------------------------------------------- rustdoc does not generate documentation for expressions
[INFO] [stdout]     |
[INFO] [stdout]     = help: use `//` for a plain comment
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::domain::table::SysRole`
[INFO] [stdout]  --> src/service/sys_user_role_service.rs:7:5
[INFO] [stdout]   |
[INFO] [stdout] 7 | use crate::domain::table::SysRole;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]   --> src/service/sys_user_role_service.rs:44:9
[INFO] [stdout]    |
[INFO] [stdout] 44 |         /// 形成角色
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 45 |         let mut user_role = SysUserRole::from(arg);
[INFO] [stdout]    |         ------------------------------------------- rustdoc does not generate documentation for statements
[INFO] [stdout]    |
[INFO] [stdout]    = help: use `//` for a plain comment
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `actix_web::guard`
[INFO] [stdout]  --> src/service/mem_service.rs:1:5
[INFO] [stdout]   |
[INFO] [stdout] 1 | use actix_web::guard;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `res`
[INFO] [stdout]  --> src/service/sys_role_service.rs:8:13
[INFO] [stdout]   |
[INFO] [stdout] 8 |             res,
[INFO] [stdout]   |             ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary parentheses around type
[INFO] [stdout]    --> src/service/sys_role_service.rs:139:52
[INFO] [stdout]     |
[INFO] [stdout] 139 |     pub async fn remove(&self, id: &str) -> Result<(u64)> {
[INFO] [stdout]     |                                                    ^   ^
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(unused_parens)]` on by default
[INFO] [stdout] help: remove these parentheses
[INFO] [stdout]     |
[INFO] [stdout] 139 -     pub async fn remove(&self, id: &str) -> Result<(u64)> {
[INFO] [stdout] 139 +     pub async fn remove(&self, id: &str) -> Result<u64> {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `sys_role_service::SysRoleService`
[INFO] [stdout]   --> src/service/sys_res_service.rs:15:13
[INFO] [stdout]    |
[INFO] [stdout] 15 | use super::{sys_role_service::SysRoleService, CONTEXT};
[INFO] [stdout]    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]    --> src/service/sys_res_service.rs:102:9
[INFO] [stdout]     |
[INFO] [stdout] 102 |         /// 之后可以添加代码实现打印日志
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 103 |         let mut arr = vec![];
[INFO] [stdout]     |         --------------------- rustdoc does not generate documentation for statements
[INFO] [stdout]     |
[INFO] [stdout]     = help: use `//` for a plain comment
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]   --> src/service/sys_dict_service.rs:47:9
[INFO] [stdout]    |
[INFO] [stdout] 47 | /         /// 以后逻辑可能会改
[INFO] [stdout] 48 | |         ///
[INFO] [stdout]    | |___________^
[INFO] [stdout] 49 |           let res = SysDict::update_by_column(pool!(), &data, "id").await?;
[INFO] [stdout]    |           ----------------------------------------------------------------- rustdoc does not generate documentation for statements
[INFO] [stdout]    |
[INFO] [stdout]    = help: use `//` for a plain comment
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `super::*`
[INFO] [stdout]    --> src/service/mod.rs:141:9
[INFO] [stdout]     |
[INFO] [stdout] 141 |     use super::*;
[INFO] [stdout]     |         ^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `serde::de::Visitor`
[INFO] [stdout]  --> src/error.rs:6:5
[INFO] [stdout]   |
[INFO] [stdout] 6 | use serde::de::Visitor;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused imports: `Serialize`, `Serializer`
[INFO] [stdout]  --> src/error.rs:7:18
[INFO] [stdout]   |
[INFO] [stdout] 7 | use serde::ser::{Serialize, Serializer};
[INFO] [stdout]   |                  ^^^^^^^^^  ^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused imports: `Deserialize`, `Deserializer`
[INFO] [stdout]  --> src/error.rs:8:13
[INFO] [stdout]   |
[INFO] [stdout] 8 | use serde::{Deserialize, Deserializer};
[INFO] [stdout]   |             ^^^^^^^^^^^  ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `rbatis::object_id::ObjectId`
[INFO] [stdout]  --> src/domain/dto/user.rs:1:5
[INFO] [stdout]   |
[INFO] [stdout] 1 | use rbatis::object_id::ObjectId;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::util::password_encoder::PasswordEncoder`
[INFO] [stdout]  --> src/domain/dto/user.rs:9:5
[INFO] [stdout]   |
[INFO] [stdout] 9 | use crate::util::password_encoder::PasswordEncoder;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: type `JWT_Token` should have an upper camel case name
[INFO] [stdout]  --> src/domain/vo/jwt.rs:9:12
[INFO] [stdout]   |
[INFO] [stdout] 9 | pub struct JWT_Token {
[INFO] [stdout]   |            ^^^^^^^^^ help: convert the identifier to upper camel case: `JwtToken`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]  --> src/domain/mapper/sys_user.rs:3:1
[INFO] [stdout]   |
[INFO] [stdout] 3 | / /// 后台用户表 过程宏
[INFO] [stdout] 4 | | /// 只有使用了crud！ 这个宏之后，才能生成之后的宏
[INFO] [stdout]   | |_------------------------------------------------^
[INFO] [stdout]   |   |
[INFO] [stdout]   |   rustdoc does not generate documentation for macro invocations
[INFO] [stdout]   |
[INFO] [stdout]   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]  --> src/domain/mapper/sys_user_role.rs:3:1
[INFO] [stdout]   |
[INFO] [stdout] 3 | / /// 后台用户角色表 过程宏
[INFO] [stdout] 4 | | /// 只有使用了crud！ 这个宏之后，才能生成之后的宏
[INFO] [stdout]   | |_------------------------------------------------^
[INFO] [stdout]   |   |
[INFO] [stdout]   |   rustdoc does not generate documentation for macro invocations
[INFO] [stdout]   |
[INFO] [stdout]   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]  --> src/domain/mapper/sys_dict.rs:4:1
[INFO] [stdout]   |
[INFO] [stdout] 4 | / /// 系统字典表 过程宏
[INFO] [stdout] 5 | | /// 只有使用了crud！ 这个宏之后，才能生成之后的宏
[INFO] [stdout]   | |_------------------------------------------------^
[INFO] [stdout]   |   |
[INFO] [stdout]   |   rustdoc does not generate documentation for macro invocations
[INFO] [stdout]   |
[INFO] [stdout]   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::domain::table::enums::LoginCheck`
[INFO] [stdout]    --> src/domain/table/tables.rs:103:9
[INFO] [stdout]     |
[INFO] [stdout] 103 |     use crate::domain::table::enums::LoginCheck;
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `super::*`
[INFO] [stdout]    --> src/domain/table/tables.rs:105:9
[INFO] [stdout]     |
[INFO] [stdout] 105 |     use super::*;
[INFO] [stdout]     |         ^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::service::CONTEXT`
[INFO] [stdout]   --> src/middleware/auth_actix.rs:13:5
[INFO] [stdout]    |
[INFO] [stdout] 13 | use crate::service::CONTEXT;
[INFO] [stdout]    |     ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]   --> src/service/sys_user_role_service.rs:24:13
[INFO] [stdout]    |
[INFO] [stdout] 24 |         let mut vo = CONTEXT
[INFO] [stdout]    |             ----^^
[INFO] [stdout]    |             |
[INFO] [stdout]    |             help: remove this `mut`
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(unused_mut)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]    --> src/service/sys_role_service.rs:128:13
[INFO] [stdout]     |
[INFO] [stdout] 128 |         let mut role = SysRole::from(arg);
[INFO] [stdout]     |             ----^^^^
[INFO] [stdout]     |             |
[INFO] [stdout]     |             help: remove this `mut`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]   --> src/controller/sys_dict_controller.rs:41:21
[INFO] [stdout]    |
[INFO] [stdout] 41 | pub async fn update(mut arg: web::Json<DictEditDTO>) -> impl Responder {
[INFO] [stdout]    |                     ----^^^
[INFO] [stdout]    |                     |
[INFO] [stdout]    |                     help: remove this `mut`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]   --> src/controller/sys_dict_controller.rs:49:21
[INFO] [stdout]    |
[INFO] [stdout] 49 | pub async fn remove(mut arg: web::Json<IdDTO>) -> impl Responder {
[INFO] [stdout]    |                     ----^^^
[INFO] [stdout]    |                     |
[INFO] [stdout]    |                     help: remove this `mut`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unreachable pattern
[INFO] [stdout]   --> src/service/sys_sms_service.rs:40:13
[INFO] [stdout]    |
[INFO] [stdout] 39 |             _ => Err(Error::from("请发送验证码")),
[INFO] [stdout]    |             - matches any value
[INFO] [stdout] 40 |             Some(v) => {
[INFO] [stdout]    |             ^^^^^^^ unreachable pattern
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(unreachable_patterns)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unreachable pattern
[INFO] [stdout]   --> src/domain/vo/role.rs:41:13
[INFO] [stdout]    |
[INFO] [stdout] 40 |             _ => None,
[INFO] [stdout]    |             - matches any value
[INFO] [stdout] 41 |             Some(arg) => Some(SysRoleVO {
[INFO] [stdout]    |             ^^^^^^^^^ unreachable pattern
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `interimVO` should have a snake case name
[INFO] [stdout]    --> src/service/sys_user_service.rs:126:17
[INFO] [stdout]     |
[INFO] [stdout] 126 |         let mut interimVO = SignVO {
[INFO] [stdout]     |                 ^^^^^^^^^ help: convert the identifier to snake case: `interim_vo`
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(non_snake_case)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: 36 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]    Compiling backend v0.1.0 (/opt/rustwide/workdir)
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] insert_batch(rb : & mut dyn rbatis :: executor :: Executor, tables : &
[INFO] [stdout] [SysRes], table_name : & str,) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("tables".to_string().into(), rbs ::
[INFO] [stdout]     to_value(tables).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(65usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("insert into ${table_name} ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(35usize) ; for(idx, table)
[INFO] [stdout]             in { & arg ["tables"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if { (idx).op_eq(& 0i64) }.to_owned().into()
[INFO] [stdout]                 {
[INFO] [stdout]                     sql.push_str("(") ;
[INFO] [stdout]                     sql.push_str(&
[INFO] [stdout]                     {
[INFO] [stdout]                         let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                         { table }
[INFO] [stdout]                         {
[INFO] [stdout]                             if
[INFO] [stdout]                             {
[INFO] [stdout]                                 bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                                 op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                             }.to_owned().into() { continue }
[INFO] [stdout]                             sql.push_str("${k},".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                             1).as_str()) ;
[INFO] [stdout]                         } sql =
[INFO] [stdout]                         sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                         ; sql
[INFO] [stdout]                     }) ; sql.push_str(") VALUES ") ;
[INFO] [stdout]                 } sql.push_str("(") ;
[INFO] [stdout]                 sql.push_str(&
[INFO] [stdout]                 {
[INFO] [stdout]                     let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                     { table }
[INFO] [stdout]                     {
[INFO] [stdout]                         if
[INFO] [stdout]                         {
[INFO] [stdout]                             bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                             op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                         }.to_owned().into() { continue }
[INFO] [stdout]                         args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                         sql.push_str("?,") ;
[INFO] [stdout]                     } sql =
[INFO] [stdout]                     sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                     ; sql
[INFO] [stdout]                 }) ; sql.push_str("),") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_all(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str,) -> std :: result :: Result < Vec < SysRes >, rbatis
[INFO] [stdout] :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(44usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} ".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_value : V,) -> std :: result ::
[INFO] [stdout] Result < Vec < SysRes >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} = ?".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_values : & [V],) -> std :: result
[INFO] [stdout] :: Result < Vec < SysRes >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} in (".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] update_by_column_value(rb : & mut dyn rbatis :: executor :: Executor,
[INFO] [stdout] table_name : String, table : & rbs :: Value, column : & str, column_value :
[INFO] [stdout] & rbs :: Value,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(77usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("update ${table_name} set ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(12usize) ; for(k, v) in
[INFO] [stdout]             { & arg ["table"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if
[INFO] [stdout]                 {
[INFO] [stdout]                     bool :: op_from((k).op_eq(& & arg ["column"])) || bool ::
[INFO] [stdout]                     op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                 }.to_owned().into() { continue }
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("${k}=?,".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                 1).as_str()) ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str(" where ${column} = ?".replacen("${column}", &
[INFO] [stdout]         { & arg ["column"] }.as_sql(), 1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_value : V,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} = ?".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column_batch < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(60usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(7usize) ; for(_, v) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_page(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str, dto : & crate :: domain :: dto :: res :: ResPageDTO,)
[INFO] [stdout] -> std :: result :: Result < u64, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("dto".to_string().into(), rbs ::
[INFO] [stdout]     to_value(dto).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(152usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select count(1) as count from ${table_name} where del = 0 ".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(), 1).as_str()) ; if
[INFO] [stdout]         {
[INFO] [stdout]             bool ::
[INFO] [stdout]             op_from(((& arg ["dto"] ["name"])).op_ne(& rbs :: Value :: Null))
[INFO] [stdout]             && bool :: op_from(((& arg ["dto"] ["name"])).op_ne(& ""))
[INFO] [stdout]         }.to_owned().into() {}
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({
[INFO] [stdout]             ((String ::
[INFO] [stdout]             from("%")).op_add((& arg ["dto"] ["name"]))).op_add(& "%")
[INFO] [stdout]         }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str(" and name like ?and parent_id IS NULL") ; if
[INFO] [stdout]         { ! sql.contains("count") }.to_owned().into() {}
[INFO] [stdout]         sql.push_str("order by create_date desc") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_page(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str, page_no : u64, page_size : u64, page_offset : u64,
[INFO] [stdout] limit_sql : & str, dto : & crate :: domain :: dto :: res :: ResPageDTO,) ->
[INFO] [stdout] std :: result :: Result < Vec < SysRes >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("page_no".to_string().into(), rbs ::
[INFO] [stdout]     to_value(page_no).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("page_size".to_string().into(), rbs ::
[INFO] [stdout]     to_value(page_size).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("page_offset".to_string().into(), rbs ::
[INFO] [stdout]     to_value(page_offset).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("limit_sql".to_string().into(), rbs ::
[INFO] [stdout]     to_value(limit_sql).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("dto".to_string().into(), rbs ::
[INFO] [stdout]     to_value(dto).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(164usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} where del = 0 ".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; if
[INFO] [stdout]         {
[INFO] [stdout]             bool ::
[INFO] [stdout]             op_from(((& arg ["dto"] ["name"])).op_ne(& rbs :: Value :: Null))
[INFO] [stdout]             && bool :: op_from(((& arg ["dto"] ["name"])).op_ne(& ""))
[INFO] [stdout]         }.to_owned().into() {}
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({
[INFO] [stdout]             ((String ::
[INFO] [stdout]             from("%")).op_add((& arg ["dto"] ["name"]))).op_add(& "%")
[INFO] [stdout]         }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str(" and name like ?and parent_id IS NULL") ; if
[INFO] [stdout]         { ! sql.contains("count") }.to_owned().into() {}
[INFO] [stdout]         sql.push_str("order by create_date desc") ; if
[INFO] [stdout]         {
[INFO] [stdout]             bool :: op_from(! sql.contains("page_no")) && bool ::
[INFO] [stdout]             op_from(! sql.contains("page_size"))
[INFO] [stdout]         }.to_owned().into()
[INFO] [stdout]         {
[INFO] [stdout]             sql.push_str("${limit_sql}".replacen("${limit_sql}", &
[INFO] [stdout]             { & arg ["limit_sql"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         } return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_by_permission_or_name(rb : & mut dyn rbatis :: executor :: Executor,
[INFO] [stdout] table_column : & str, table_name : & str, permission : & str, name : & str,)
[INFO] [stdout] -> std :: result :: Result < Vec < SysRes >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("permission".to_string().into(), rbs ::
[INFO] [stdout]     to_value(permission).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(95usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["permission"] }).unwrap_or_default()) ;
[INFO] [stdout]         args.push(rbs :: to_value({ & arg ["name"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} where permission =? or name = ?".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_by_ids(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str, ids : & Vec < String >,) -> std :: result :: Result <
[INFO] [stdout] Vec < SysRes >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("ids".to_string().into(), rbs ::
[INFO] [stdout]     to_value(ids).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(70usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} where id in (".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(0usize) ; for(_, id) in
[INFO] [stdout]             { & arg ["ids"] } {} sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; args.push(rbs :: to_value({ & arg ["id"] }).unwrap_or_default())
[INFO] [stdout]         ; sql.push_str("?,)") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_by_parent_id_null(rb : & mut dyn rbatis :: executor :: Executor,
[INFO] [stdout] table_column : & str, table_name : & str,) -> std :: result :: Result < Vec <
[INFO] [stdout] SysRes >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(95usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} where parent_id IS NULL order by create_date desc".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] insert_batch(rb : & mut dyn rbatis :: executor :: Executor, tables : &
[INFO] [stdout] [SysRole], table_name : & str,) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("tables".to_string().into(), rbs ::
[INFO] [stdout]     to_value(tables).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(65usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("insert into ${table_name} ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(35usize) ; for(idx, table)
[INFO] [stdout]             in { & arg ["tables"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if { (idx).op_eq(& 0i64) }.to_owned().into()
[INFO] [stdout]                 {
[INFO] [stdout]                     sql.push_str("(") ;
[INFO] [stdout]                     sql.push_str(&
[INFO] [stdout]                     {
[INFO] [stdout]                         let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                         { table }
[INFO] [stdout]                         {
[INFO] [stdout]                             if
[INFO] [stdout]                             {
[INFO] [stdout]                                 bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                                 op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                             }.to_owned().into() { continue }
[INFO] [stdout]                             sql.push_str("${k},".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                             1).as_str()) ;
[INFO] [stdout]                         } sql =
[INFO] [stdout]                         sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                         ; sql
[INFO] [stdout]                     }) ; sql.push_str(") VALUES ") ;
[INFO] [stdout]                 } sql.push_str("(") ;
[INFO] [stdout]                 sql.push_str(&
[INFO] [stdout]                 {
[INFO] [stdout]                     let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                     { table }
[INFO] [stdout]                     {
[INFO] [stdout]                         if
[INFO] [stdout]                         {
[INFO] [stdout]                             bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                             op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                         }.to_owned().into() { continue }
[INFO] [stdout]                         args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                         sql.push_str("?,") ;
[INFO] [stdout]                     } sql =
[INFO] [stdout]                     sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                     ; sql
[INFO] [stdout]                 }) ; sql.push_str("),") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_all(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str,) -> std :: result :: Result < Vec < SysRole >, rbatis
[INFO] [stdout] :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(44usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} ".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_value : V,) -> std :: result ::
[INFO] [stdout] Result < Vec < SysRole >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} = ?".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_values : & [V],) -> std :: result
[INFO] [stdout] :: Result < Vec < SysRole >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} in (".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] update_by_column_value(rb : & mut dyn rbatis :: executor :: Executor,
[INFO] [stdout] table_name : String, table : & rbs :: Value, column : & str, column_value :
[INFO] [stdout] & rbs :: Value,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(77usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("update ${table_name} set ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(12usize) ; for(k, v) in
[INFO] [stdout]             { & arg ["table"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if
[INFO] [stdout]                 {
[INFO] [stdout]                     bool :: op_from((k).op_eq(& & arg ["column"])) || bool ::
[INFO] [stdout]                     op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                 }.to_owned().into() { continue }
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("${k}=?,".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                 1).as_str()) ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str(" where ${column} = ?".replacen("${column}", &
[INFO] [stdout]         { & arg ["column"] }.as_sql(), 1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_value : V,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} = ?".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column_batch < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(60usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(7usize) ; for(_, v) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_list_by_ids(rb : & mut dyn rbatis :: executor :: Executor, table_column
[INFO] [stdout] : & str, table_name : & str, ids : & [String],) -> std :: result :: Result <
[INFO] [stdout] Vec < SysRole >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("ids".to_string().into(), rbs ::
[INFO] [stdout]     to_value(ids).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(72usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} where id in (".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(0usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["ids"] } {} sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ;
[INFO] [stdout]         args.push(rbs :: to_value({ & arg ["item"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("?,)") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_page_by_name(rb : & mut dyn rbatis :: executor :: Executor,
[INFO] [stdout] table_column : & str, table_name : & str, name : & str,) -> std :: result ::
[INFO] [stdout] Result < u64, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(143usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select count(1) as count from ${table_name} where del = 0".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(), 1).as_str()) ; if
[INFO] [stdout]         { (& arg ["name"]).op_ne(& "") }.to_owned().into() {}
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({
[INFO] [stdout]             ((String :: from("%")).op_add(& arg ["name"])).op_add(& "%")
[INFO] [stdout]         }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str(" and name like ?and parent_id IS NULL") ; if
[INFO] [stdout]         { ! sql.contains("count") }.to_owned().into() {}
[INFO] [stdout]         sql.push_str("order by create_date desc") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_page_by_name(rb : & mut dyn rbatis :: executor :: Executor,
[INFO] [stdout] table_column : & str, table_name : & str, page_no : u64, page_size : u64,
[INFO] [stdout] page_offset : u64, limit_sql : & str, name : & str,) -> std :: result ::
[INFO] [stdout] Result < Vec < SysRole >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("page_no".to_string().into(), rbs ::
[INFO] [stdout]     to_value(page_no).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("page_size".to_string().into(), rbs ::
[INFO] [stdout]     to_value(page_size).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("page_offset".to_string().into(), rbs ::
[INFO] [stdout]     to_value(page_offset).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("limit_sql".to_string().into(), rbs ::
[INFO] [stdout]     to_value(limit_sql).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(155usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} where del = 0".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; if { (& arg ["name"]).op_ne(& "") }.to_owned().into()
[INFO] [stdout]         {}
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({
[INFO] [stdout]             ((String :: from("%")).op_add(& arg ["name"])).op_add(& "%")
[INFO] [stdout]         }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str(" and name like ?and parent_id IS NULL") ; if
[INFO] [stdout]         { ! sql.contains("count") }.to_owned().into() {}
[INFO] [stdout]         sql.push_str("order by create_date desc") ; if
[INFO] [stdout]         {
[INFO] [stdout]             bool :: op_from(! sql.contains("page_no")) && bool ::
[INFO] [stdout]             op_from(! sql.contains("page_size"))
[INFO] [stdout]         }.to_owned().into()
[INFO] [stdout]         {
[INFO] [stdout]             sql.push_str("${limit_sql}".replacen("${limit_sql}", &
[INFO] [stdout]             { & arg ["limit_sql"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         } return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] insert_batch(rb : & mut dyn rbatis :: executor :: Executor, tables : &
[INFO] [stdout] [SysRoleRes], table_name : & str,) -> std :: result :: Result < rbatis :: rbdc
[INFO] [stdout] :: db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("tables".to_string().into(), rbs ::
[INFO] [stdout]     to_value(tables).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(65usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("insert into ${table_name} ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(35usize) ; for(idx, table)
[INFO] [stdout]             in { & arg ["tables"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if { (idx).op_eq(& 0i64) }.to_owned().into()
[INFO] [stdout]                 {
[INFO] [stdout]                     sql.push_str("(") ;
[INFO] [stdout]                     sql.push_str(&
[INFO] [stdout]                     {
[INFO] [stdout]                         let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                         { table }
[INFO] [stdout]                         {
[INFO] [stdout]                             if
[INFO] [stdout]                             {
[INFO] [stdout]                                 bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                                 op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                             }.to_owned().into() { continue }
[INFO] [stdout]                             sql.push_str("${k},".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                             1).as_str()) ;
[INFO] [stdout]                         } sql =
[INFO] [stdout]                         sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                         ; sql
[INFO] [stdout]                     }) ; sql.push_str(") VALUES ") ;
[INFO] [stdout]                 } sql.push_str("(") ;
[INFO] [stdout]                 sql.push_str(&
[INFO] [stdout]                 {
[INFO] [stdout]                     let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                     { table }
[INFO] [stdout]                     {
[INFO] [stdout]                         if
[INFO] [stdout]                         {
[INFO] [stdout]                             bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                             op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                         }.to_owned().into() { continue }
[INFO] [stdout]                         args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                         sql.push_str("?,") ;
[INFO] [stdout]                     } sql =
[INFO] [stdout]                     sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                     ; sql
[INFO] [stdout]                 }) ; sql.push_str("),") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_all(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str,) -> std :: result :: Result < Vec < SysRoleRes >,
[INFO] [stdout] rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(44usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} ".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_value : V,) -> std :: result ::
[INFO] [stdout] Result < Vec < SysRoleRes >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} = ?".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_values : & [V],) -> std :: result
[INFO] [stdout] :: Result < Vec < SysRoleRes >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} in (".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] update_by_column_value(rb : & mut dyn rbatis :: executor :: Executor,
[INFO] [stdout] table_name : String, table : & rbs :: Value, column : & str, column_value :
[INFO] [stdout] & rbs :: Value,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(77usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("update ${table_name} set ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(12usize) ; for(k, v) in
[INFO] [stdout]             { & arg ["table"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if
[INFO] [stdout]                 {
[INFO] [stdout]                     bool :: op_from((k).op_eq(& & arg ["column"])) || bool ::
[INFO] [stdout]                     op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                 }.to_owned().into() { continue }
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("${k}=?,".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                 1).as_str()) ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str(" where ${column} = ?".replacen("${column}", &
[INFO] [stdout]         { & arg ["column"] }.as_sql(), 1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_value : V,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} = ?".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column_batch < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(60usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(7usize) ; for(_, v) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_by_role_id(rb : & mut dyn rbatis :: executor :: Executor, table_column
[INFO] [stdout] : & str, table_name : & str, role_ids : & [String],) -> std :: result ::
[INFO] [stdout] Result < Vec < SysRoleRes >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("role_ids".to_string().into(), rbs ::
[INFO] [stdout]     to_value(role_ids).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(77usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} where role_id in (".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(0usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["role_ids"] } {} sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ;
[INFO] [stdout]         args.push(rbs :: to_value({ & arg ["item"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("?,)") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] insert_batch(rb : & mut dyn rbatis :: executor :: Executor, tables : &
[INFO] [stdout] [SysUser], table_name : & str,) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("tables".to_string().into(), rbs ::
[INFO] [stdout]     to_value(tables).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(65usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("insert into ${table_name} ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(35usize) ; for(idx, table)
[INFO] [stdout]             in { & arg ["tables"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if { (idx).op_eq(& 0i64) }.to_owned().into()
[INFO] [stdout]                 {
[INFO] [stdout]                     sql.push_str("(") ;
[INFO] [stdout]                     sql.push_str(&
[INFO] [stdout]                     {
[INFO] [stdout]                         let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                         { table }
[INFO] [stdout]                         {
[INFO] [stdout]                             if
[INFO] [stdout]                             {
[INFO] [stdout]                                 bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                                 op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                             }.to_owned().into() { continue }
[INFO] [stdout]                             sql.push_str("${k},".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                             1).as_str()) ;
[INFO] [stdout]                         } sql =
[INFO] [stdout]                         sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                         ; sql
[INFO] [stdout]                     }) ; sql.push_str(") VALUES ") ;
[INFO] [stdout]                 } sql.push_str("(") ;
[INFO] [stdout]                 sql.push_str(&
[INFO] [stdout]                 {
[INFO] [stdout]                     let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                     { table }
[INFO] [stdout]                     {
[INFO] [stdout]                         if
[INFO] [stdout]                         {
[INFO] [stdout]                             bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                             op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                         }.to_owned().into() { continue }
[INFO] [stdout]                         args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                         sql.push_str("?,") ;
[INFO] [stdout]                     } sql =
[INFO] [stdout]                     sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                     ; sql
[INFO] [stdout]                 }) ; sql.push_str("),") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_all(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str,) -> std :: result :: Result < Vec < SysUser >, rbatis
[INFO] [stdout] :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(44usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} ".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_value : V,) -> std :: result ::
[INFO] [stdout] Result < Vec < SysUser >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} = ?".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_values : & [V],) -> std :: result
[INFO] [stdout] :: Result < Vec < SysUser >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} in (".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] update_by_column_value(rb : & mut dyn rbatis :: executor :: Executor,
[INFO] [stdout] table_name : String, table : & rbs :: Value, column : & str, column_value :
[INFO] [stdout] & rbs :: Value,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(77usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("update ${table_name} set ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(12usize) ; for(k, v) in
[INFO] [stdout]             { & arg ["table"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if
[INFO] [stdout]                 {
[INFO] [stdout]                     bool :: op_from((k).op_eq(& & arg ["column"])) || bool ::
[INFO] [stdout]                     op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                 }.to_owned().into() { continue }
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("${k}=?,".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                 1).as_str()) ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str(" where ${column} = ?".replacen("${column}", &
[INFO] [stdout]         { & arg ["column"] }.as_sql(), 1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_value : V,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} = ?".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column_batch < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(60usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(7usize) ; for(_, v) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_page(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str, name : & str, account : & str,) -> std :: result ::
[INFO] [stdout] Result < u64, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("account".to_string().into(), rbs ::
[INFO] [stdout]     to_value(account).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(159usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select count(1) as count from ${table_name} where del=0".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(), 1).as_str()) ; if
[INFO] [stdout]         { (& arg ["name"]).op_ne(& "") }.to_owned().into() {}
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({
[INFO] [stdout]             ((String :: from("%")).op_add(& arg ["name"])).op_add(& "%")
[INFO] [stdout]         }).unwrap_or_default()) ; sql.push_str(" and name like ?") ; if
[INFO] [stdout]         { (& arg ["account"]).op_ne(& "") }.to_owned().into() {}
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({
[INFO] [stdout]             ((String :: from("%")).op_add(& arg ["account"])).op_add(& "%")
[INFO] [stdout]         }).unwrap_or_default()) ; sql.push_str(" and account like ?") ; if
[INFO] [stdout]         { ! sql.contains("count") }.to_owned().into() {}
[INFO] [stdout]         sql.push_str("order by create data desc") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_page(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str, page_no : u64, page_size : u64, page_offset : u64,
[INFO] [stdout] limit_sql : & str, name : & str, account : & str,) -> std :: result :: Result
[INFO] [stdout] < Vec < SysUser >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("page_no".to_string().into(), rbs ::
[INFO] [stdout]     to_value(page_no).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("page_size".to_string().into(), rbs ::
[INFO] [stdout]     to_value(page_size).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("page_offset".to_string().into(), rbs ::
[INFO] [stdout]     to_value(page_offset).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("limit_sql".to_string().into(), rbs ::
[INFO] [stdout]     to_value(limit_sql).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("account".to_string().into(), rbs ::
[INFO] [stdout]     to_value(account).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(171usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} where del=0".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; if { (& arg ["name"]).op_ne(& "") }.to_owned().into()
[INFO] [stdout]         {}
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({
[INFO] [stdout]             ((String :: from("%")).op_add(& arg ["name"])).op_add(& "%")
[INFO] [stdout]         }).unwrap_or_default()) ; sql.push_str(" and name like ?") ; if
[INFO] [stdout]         { (& arg ["account"]).op_ne(& "") }.to_owned().into() {}
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({
[INFO] [stdout]             ((String :: from("%")).op_add(& arg ["account"])).op_add(& "%")
[INFO] [stdout]         }).unwrap_or_default()) ; sql.push_str(" and account like ?") ; if
[INFO] [stdout]         { ! sql.contains("count") }.to_owned().into() {}
[INFO] [stdout]         sql.push_str("order by create data desc") ; if
[INFO] [stdout]         {
[INFO] [stdout]             bool :: op_from(! sql.contains("page_no")) && bool ::
[INFO] [stdout]             op_from(! sql.contains("page_size"))
[INFO] [stdout]         }.to_owned().into()
[INFO] [stdout]         {
[INFO] [stdout]             sql.push_str("${limit_sql}".replacen("${limit_sql}", &
[INFO] [stdout]             { & arg ["limit_sql"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         } return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] insert_batch(rb : & mut dyn rbatis :: executor :: Executor, tables : &
[INFO] [stdout] [SysUserRole], table_name : & str,) -> std :: result :: Result < rbatis ::
[INFO] [stdout] rbdc :: db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("tables".to_string().into(), rbs ::
[INFO] [stdout]     to_value(tables).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(65usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("insert into ${table_name} ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(35usize) ; for(idx, table)
[INFO] [stdout]             in { & arg ["tables"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if { (idx).op_eq(& 0i64) }.to_owned().into()
[INFO] [stdout]                 {
[INFO] [stdout]                     sql.push_str("(") ;
[INFO] [stdout]                     sql.push_str(&
[INFO] [stdout]                     {
[INFO] [stdout]                         let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                         { table }
[INFO] [stdout]                         {
[INFO] [stdout]                             if
[INFO] [stdout]                             {
[INFO] [stdout]                                 bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                                 op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                             }.to_owned().into() { continue }
[INFO] [stdout]                             sql.push_str("${k},".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                             1).as_str()) ;
[INFO] [stdout]                         } sql =
[INFO] [stdout]                         sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                         ; sql
[INFO] [stdout]                     }) ; sql.push_str(") VALUES ") ;
[INFO] [stdout]                 } sql.push_str("(") ;
[INFO] [stdout]                 sql.push_str(&
[INFO] [stdout]                 {
[INFO] [stdout]                     let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                     { table }
[INFO] [stdout]                     {
[INFO] [stdout]                         if
[INFO] [stdout]                         {
[INFO] [stdout]                             bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                             op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                         }.to_owned().into() { continue }
[INFO] [stdout]                         args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                         sql.push_str("?,") ;
[INFO] [stdout]                     } sql =
[INFO] [stdout]                     sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                     ; sql
[INFO] [stdout]                 }) ; sql.push_str("),") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_all(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str,) -> std :: result :: Result < Vec < SysUserRole >,
[INFO] [stdout] rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(44usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} ".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_value : V,) -> std :: result ::
[INFO] [stdout] Result < Vec < SysUserRole >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} = ?".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_values : & [V],) -> std :: result
[INFO] [stdout] :: Result < Vec < SysUserRole >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} in (".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] update_by_column_value(rb : & mut dyn rbatis :: executor :: Executor,
[INFO] [stdout] table_name : String, table : & rbs :: Value, column : & str, column_value :
[INFO] [stdout] & rbs :: Value,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(77usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("update ${table_name} set ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(12usize) ; for(k, v) in
[INFO] [stdout]             { & arg ["table"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if
[INFO] [stdout]                 {
[INFO] [stdout]                     bool :: op_from((k).op_eq(& & arg ["column"])) || bool ::
[INFO] [stdout]                     op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                 }.to_owned().into() { continue }
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("${k}=?,".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                 1).as_str()) ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str(" where ${column} = ?".replacen("${column}", &
[INFO] [stdout]         { & arg ["column"] }.as_sql(), 1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_value : V,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} = ?".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column_batch < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(60usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(7usize) ; for(_, v) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_list_in_user_id(rb : & mut dyn rbatis :: executor :: Executor,
[INFO] [stdout] table_column : & str, table_name : & str, user_ids : & [String],) -> std ::
[INFO] [stdout] result :: Result < Vec < SysUserRole >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("user_ids".to_string().into(), rbs ::
[INFO] [stdout]     to_value(user_ids).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(74usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} where user_id in (".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(0usize) ; for(_, v) in
[INFO] [stdout]             { & arg ["user_ids"] } {} sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; args.push(rbs :: to_value({ & arg ["v"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("?,)") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] insert_batch(rb : & mut dyn rbatis :: executor :: Executor, tables : &
[INFO] [stdout] [SysTrash], table_name : & str,) -> std :: result :: Result < rbatis :: rbdc
[INFO] [stdout] :: db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("tables".to_string().into(), rbs ::
[INFO] [stdout]     to_value(tables).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(65usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("insert into ${table_name} ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(35usize) ; for(idx, table)
[INFO] [stdout]             in { & arg ["tables"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if { (idx).op_eq(& 0i64) }.to_owned().into()
[INFO] [stdout]                 {
[INFO] [stdout]                     sql.push_str("(") ;
[INFO] [stdout]                     sql.push_str(&
[INFO] [stdout]                     {
[INFO] [stdout]                         let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                         { table }
[INFO] [stdout]                         {
[INFO] [stdout]                             if
[INFO] [stdout]                             {
[INFO] [stdout]                                 bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                                 op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                             }.to_owned().into() { continue }
[INFO] [stdout]                             sql.push_str("${k},".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                             1).as_str()) ;
[INFO] [stdout]                         } sql =
[INFO] [stdout]                         sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                         ; sql
[INFO] [stdout]                     }) ; sql.push_str(") VALUES ") ;
[INFO] [stdout]                 } sql.push_str("(") ;
[INFO] [stdout]                 sql.push_str(&
[INFO] [stdout]                 {
[INFO] [stdout]                     let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                     { table }
[INFO] [stdout]                     {
[INFO] [stdout]                         if
[INFO] [stdout]                         {
[INFO] [stdout]                             bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                             op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                         }.to_owned().into() { continue }
[INFO] [stdout]                         args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                         sql.push_str("?,") ;
[INFO] [stdout]                     } sql =
[INFO] [stdout]                     sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                     ; sql
[INFO] [stdout]                 }) ; sql.push_str("),") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_all(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str,) -> std :: result :: Result < Vec < SysTrash >,
[INFO] [stdout] rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(44usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} ".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_value : V,) -> std :: result ::
[INFO] [stdout] Result < Vec < SysTrash >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} = ?".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_values : & [V],) -> std :: result
[INFO] [stdout] :: Result < Vec < SysTrash >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} in (".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] update_by_column_value(rb : & mut dyn rbatis :: executor :: Executor,
[INFO] [stdout] table_name : String, table : & rbs :: Value, column : & str, column_value :
[INFO] [stdout] & rbs :: Value,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(77usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("update ${table_name} set ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(12usize) ; for(k, v) in
[INFO] [stdout]             { & arg ["table"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if
[INFO] [stdout]                 {
[INFO] [stdout]                     bool :: op_from((k).op_eq(& & arg ["column"])) || bool ::
[INFO] [stdout]                     op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                 }.to_owned().into() { continue }
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("${k}=?,".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                 1).as_str()) ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str(" where ${column} = ?".replacen("${column}", &
[INFO] [stdout]         { & arg ["column"] }.as_sql(), 1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_value : V,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} = ?".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column_batch < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(60usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(7usize) ; for(_, v) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] insert_batch(rb : & mut dyn rbatis :: executor :: Executor, tables : &
[INFO] [stdout] [SysDict], table_name : & str,) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("tables".to_string().into(), rbs ::
[INFO] [stdout]     to_value(tables).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(65usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("insert into ${table_name} ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(35usize) ; for(idx, table)
[INFO] [stdout]             in { & arg ["tables"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if { (idx).op_eq(& 0i64) }.to_owned().into()
[INFO] [stdout]                 {
[INFO] [stdout]                     sql.push_str("(") ;
[INFO] [stdout]                     sql.push_str(&
[INFO] [stdout]                     {
[INFO] [stdout]                         let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                         { table }
[INFO] [stdout]                         {
[INFO] [stdout]                             if
[INFO] [stdout]                             {
[INFO] [stdout]                                 bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                                 op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                             }.to_owned().into() { continue }
[INFO] [stdout]                             sql.push_str("${k},".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                             1).as_str()) ;
[INFO] [stdout]                         } sql =
[INFO] [stdout]                         sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                         ; sql
[INFO] [stdout]                     }) ; sql.push_str(") VALUES ") ;
[INFO] [stdout]                 } sql.push_str("(") ;
[INFO] [stdout]                 sql.push_str(&
[INFO] [stdout]                 {
[INFO] [stdout]                     let mut sql = String :: with_capacity(7usize) ; for(k, v) in
[INFO] [stdout]                     { table }
[INFO] [stdout]                     {
[INFO] [stdout]                         if
[INFO] [stdout]                         {
[INFO] [stdout]                             bool :: op_from((k).op_eq(& "id")) && bool ::
[INFO] [stdout]                             op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                         }.to_owned().into() { continue }
[INFO] [stdout]                         args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                         sql.push_str("?,") ;
[INFO] [stdout]                     } sql =
[INFO] [stdout]                     sql.trim_start_matches(",").trim_end_matches(",").to_string()
[INFO] [stdout]                     ; sql
[INFO] [stdout]                 }) ; sql.push_str("),") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_all(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str,) -> std :: result :: Result < Vec < SysDict >, rbatis
[INFO] [stdout] :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(44usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} ".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_value : V,) -> std :: result ::
[INFO] [stdout] Result < Vec < SysDict >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} = ?".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn select_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_column : & str,
[INFO] [stdout] table_name : & str, column : & str, column_values : & [V],) -> std :: result
[INFO] [stdout] :: Result < Vec < SysDict >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(80usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name}  where ${column} in (".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] update_by_column_value(rb : & mut dyn rbatis :: executor :: Executor,
[INFO] [stdout] table_name : String, table : & rbs :: Value, column : & str, column_value :
[INFO] [stdout] & rbs :: Value,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(77usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("update ${table_name} set ".replacen("${table_name}", &
[INFO] [stdout]         { & arg ["table_name"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(12usize) ; for(k, v) in
[INFO] [stdout]             { & arg ["table"] }
[INFO] [stdout]             {
[INFO] [stdout]                 if
[INFO] [stdout]                 {
[INFO] [stdout]                     bool :: op_from((k).op_eq(& & arg ["column"])) || bool ::
[INFO] [stdout]                     op_from((v).op_eq(& rbs :: Value :: Null))
[INFO] [stdout]                 }.to_owned().into() { continue }
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("${k}=?,".replacen("${k}", & { k }.as_sql(),
[INFO] [stdout]                 1).as_str()) ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str(" where ${column} = ?".replacen("${column}", &
[INFO] [stdout]         { & arg ["column"] }.as_sql(), 1).as_str()) ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_value : V,) -> std :: result :: Result < rbatis :: rbdc :: db ::
[INFO] [stdout] ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_value".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_value).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         args.push(rbs ::
[INFO] [stdout]         to_value({ & arg ["column_value"] }).unwrap_or_default()) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} = ?".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_in_column < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(63usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(10usize) ; for(_, item) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ item }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn delete_by_column_batch < V : serde :: Serialize, >
[INFO] [stdout] (rb : & mut dyn rbatis :: executor :: Executor, table_name : String, column :
[INFO] [stdout] & str, column_values : & [V],) -> std :: result :: Result < rbatis :: rbdc ::
[INFO] [stdout] db :: ExecResult, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("column_values".to_string().into(), rbs ::
[INFO] [stdout]     to_value(column_values).unwrap_or_default()) ; {} use rbatis :: executor
[INFO] [stdout]     :: { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(60usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("delete from ${table_name} where ${column} in (".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).replacen("${column}", & { & arg ["column"] }.as_sql(), 1).as_str())
[INFO] [stdout]         ;
[INFO] [stdout]         sql.push_str(&
[INFO] [stdout]         {
[INFO] [stdout]             let mut sql = String :: with_capacity(7usize) ; for(_, v) in
[INFO] [stdout]             { & arg ["column_values"] }
[INFO] [stdout]             {
[INFO] [stdout]                 args.push(rbs :: to_value({ v }).unwrap_or_default()) ;
[INFO] [stdout]                 sql.push_str("?,") ;
[INFO] [stdout]             } sql =
[INFO] [stdout]             sql.trim_start_matches(",").trim_end_matches(",").to_string() ;
[INFO] [stdout]             sql
[INFO] [stdout]         }) ; sql.push_str(")") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; rb.exec(& sql, rb_args).await
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_page(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str, dto : & DictPageDTO,) -> std :: result :: Result <
[INFO] [stdout] u64, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("dto".to_string().into(), rbs ::
[INFO] [stdout]     to_value(dto).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(132usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select count(1) as count from ${table_name} where id!=''".replacen("${table_name}",
[INFO] [stdout]         & { & arg ["table_name"] }.as_sql(), 1).as_str()) ; if
[INFO] [stdout]         {
[INFO] [stdout]             ((& arg ["dto"] ["code"])).op_ne(& rbs :: Value :: Null)
[INFO] [stdout]         }.to_owned().into()
[INFO] [stdout]         {
[INFO] [stdout]             args.push(rbs ::
[INFO] [stdout]             to_value({ (& arg ["dto"] ["code"]) }).unwrap_or_default()) ;
[INFO] [stdout]             sql.push_str(" and code = ?") ;
[INFO] [stdout]         } if
[INFO] [stdout]         {
[INFO] [stdout]             ((& arg ["dto"] ["name"])).op_ne(& rbs :: Value :: Null)
[INFO] [stdout]         }.to_owned().into()
[INFO] [stdout]         {
[INFO] [stdout]             args.push(rbs ::
[INFO] [stdout]             to_value({ (& arg ["dto"] ["name"]) }).unwrap_or_default()) ;
[INFO] [stdout]             sql.push_str(" and name = ?") ;
[INFO] [stdout]         } if { ! sql.contains("count") }.to_owned().into() {}
[INFO] [stdout]         sql.push_str("order by create data") ; return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] ............gen macro py_sql :
[INFO] [stdout]  pub async fn
[INFO] [stdout] select_page(rb : & mut dyn rbatis :: executor :: Executor, table_column : &
[INFO] [stdout] str, table_name : & str, page_no : u64, page_size : u64, page_offset : u64,
[INFO] [stdout] limit_sql : & str, dto : & DictPageDTO,) -> std :: result :: Result < Vec <
[INFO] [stdout] SysDict >, rbatis :: rbdc :: Error >
[INFO] [stdout] {
[INFO] [stdout]     let mut rb_arg_map = rbs :: value :: map :: ValueMap :: new() ;
[INFO] [stdout]     rb_arg_map.insert("table_column".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_column).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("table_name".to_string().into(), rbs ::
[INFO] [stdout]     to_value(table_name).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("page_no".to_string().into(), rbs ::
[INFO] [stdout]     to_value(page_no).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("page_size".to_string().into(), rbs ::
[INFO] [stdout]     to_value(page_size).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("page_offset".to_string().into(), rbs ::
[INFO] [stdout]     to_value(page_offset).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("limit_sql".to_string().into(), rbs ::
[INFO] [stdout]     to_value(limit_sql).unwrap_or_default()) ;
[INFO] [stdout]     rb_arg_map.insert("dto".to_string().into(), rbs ::
[INFO] [stdout]     to_value(dto).unwrap_or_default()) ; {} use rbatis :: executor ::
[INFO] [stdout]     { RbatisRef } ; let driver_type = rb.rbatis_ref().driver_type() ? ; use
[INFO] [stdout]     rbatis :: rbatis_codegen ; pub fn
[INFO] [stdout]     do_py_sql(arg : & rbs :: Value, _tag : char) ->
[INFO] [stdout]     (String, Vec < rbs :: Value >)
[INFO] [stdout]     {
[INFO] [stdout]         use rbatis_codegen :: ops :: * ; let mut sql = String ::
[INFO] [stdout]         with_capacity(144usize) ; let mut args = Vec :: with_capacity(20) ;
[INFO] [stdout]         sql.push_str("select ${table_column} from ${table_name} where id!=''".replacen("${table_column}",
[INFO] [stdout]         & { & arg ["table_column"] }.as_sql(),
[INFO] [stdout]         1).replacen("${table_name}", & { & arg ["table_name"] }.as_sql(),
[INFO] [stdout]         1).as_str()) ; if
[INFO] [stdout]         {
[INFO] [stdout]             ((& arg ["dto"] ["code"])).op_ne(& rbs :: Value :: Null)
[INFO] [stdout]         }.to_owned().into()
[INFO] [stdout]         {
[INFO] [stdout]             args.push(rbs ::
[INFO] [stdout]             to_value({ (& arg ["dto"] ["code"]) }).unwrap_or_default()) ;
[INFO] [stdout]             sql.push_str(" and code = ?") ;
[INFO] [stdout]         } if
[INFO] [stdout]         {
[INFO] [stdout]             ((& arg ["dto"] ["name"])).op_ne(& rbs :: Value :: Null)
[INFO] [stdout]         }.to_owned().into()
[INFO] [stdout]         {
[INFO] [stdout]             args.push(rbs ::
[INFO] [stdout]             to_value({ (& arg ["dto"] ["name"]) }).unwrap_or_default()) ;
[INFO] [stdout]             sql.push_str(" and name = ?") ;
[INFO] [stdout]         } if { ! sql.contains("count") }.to_owned().into() {}
[INFO] [stdout]         sql.push_str("order by create data") ; if
[INFO] [stdout]         {
[INFO] [stdout]             bool :: op_from(! sql.contains("page_no")) && bool ::
[INFO] [stdout]             op_from(! sql.contains("page_size"))
[INFO] [stdout]         }.to_owned().into()
[INFO] [stdout]         {
[INFO] [stdout]             sql.push_str("${limit_sql}".replacen("${limit_sql}", &
[INFO] [stdout]             { & arg ["limit_sql"] }.as_sql(), 1).as_str()) ;
[INFO] [stdout]         } return(sql, args) ;
[INFO] [stdout]     } let(mut sql, rb_args) =
[INFO] [stdout]     do_py_sql(& rbs :: Value :: Map(rb_arg_map), '?') ; use rbatis :: executor
[INFO] [stdout]     :: { Executor } ; let r = rb.fetch(& sql, rb_args).await ? ; rbatis ::
[INFO] [stdout]     decode :: decode(r)
[INFO] [stdout] }
[INFO] [stdout] ............gen macro py_sql end............
[INFO] [stdout] warning: trait `isEmptyString` should have an upper camel case name
[INFO] [stdout]  --> src/util/string.rs:1:11
[INFO] [stdout]   |
[INFO] [stdout] 1 | pub trait isEmptyString {
[INFO] [stdout]   |           ^^^^^^^^^^^^^ help: convert the identifier to upper camel case (notice the capitalization): `IsEmptyString`
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(non_camel_case_types)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]   --> src/controller/img_verify_controller.rs:12:5
[INFO] [stdout]    |
[INFO] [stdout] 12 |       /// 账户为空时，不输出验证码，并且报错
[INFO] [stdout]    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 13 | /     if arg.account.is_empty() {
[INFO] [stdout] 14 | |         return RespVO::<()>::from_error(&Error::from("account is empty"), "-1").resp_json();
[INFO] [stdout] 15 | |     }
[INFO] [stdout]    | |_____- rustdoc does not generate documentation for expressions
[INFO] [stdout]    |
[INFO] [stdout]    = help: use `//` for a plain comment
[INFO] [stdout]    = note: `#[warn(unused_doc_comments)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::error::Error`
[INFO] [stdout]  --> src/controller/sys_role_controller.rs:6:5
[INFO] [stdout]   |
[INFO] [stdout] 6 | use crate::error::Error;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: `#[warn(unused_imports)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]   --> src/service/sys_user_service.rs:51:9
[INFO] [stdout]    |
[INFO] [stdout] 51 |           /// 防止爆破登录
[INFO] [stdout]    |           ^^^^^^^^^^^^^^^^
[INFO] [stdout] 52 |           // println!("sign in {:?}", arg);
[INFO] [stdout] 53 | /         let user = SysUser::select_by_column(pool!(), field_name!(SysUser.account), &arg.account)
[INFO] [stdout] 54 | |             .await?
[INFO] [stdout] 55 | |             .into_iter()
[INFO] [stdout] 56 | |             .next();
[INFO] [stdout]    | |____________________- rustdoc does not generate documentation for statements
[INFO] [stdout]    |
[INFO] [stdout]    = help: use `//` for a plain comment
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]    --> src/service/sys_user_service.rs:101:13
[INFO] [stdout]     |
[INFO] [stdout] 101 |             /// 增加重试次数
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^
[INFO] [stdout] 102 |             return Err(error.unwrap());
[INFO] [stdout]     |             -------------------------- rustdoc does not generate documentation for expressions
[INFO] [stdout]     |
[INFO] [stdout]     = help: use `//` for a plain comment
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]    --> src/service/sys_user_service.rs:118:9
[INFO] [stdout]     |
[INFO] [stdout] 118 |         /// 去除密码
[INFO] [stdout]     |         ^^^^^^^^^^^^
[INFO] [stdout] 119 |         let mut user = user.clone();
[INFO] [stdout]     |         ---------------------------- rustdoc does not generate documentation for statements
[INFO] [stdout]     |
[INFO] [stdout]     = help: use `//` for a plain comment
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]    --> src/service/sys_user_service.rs:121:9
[INFO] [stdout]     |
[INFO] [stdout] 121 |           /// 拿到ID
[INFO] [stdout]     |           ^^^^^^^^^^
[INFO] [stdout] 122 | /         let user_id = user
[INFO] [stdout] 123 | |             .id
[INFO] [stdout] 124 | |             .clone()
[INFO] [stdout] 125 | |             .ok_or_else(|| Error::from("用户数据错误，id为空"))?;
[INFO] [stdout]     | |_________________________________________________________________- rustdoc does not generate documentation for statements
[INFO] [stdout]     |
[INFO] [stdout]     = help: use `//` for a plain comment
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]    --> src/service/sys_user_service.rs:253:9
[INFO] [stdout]     |
[INFO] [stdout] 253 | /         /// 记录删除日志
[INFO] [stdout] 254 | |         /// 删除对应用户的角色
[INFO] [stdout]     | |______________________________^
[INFO] [stdout] 255 |           CONTEXT.sys_user_role_service.remove_by_user_id(id).await?;
[INFO] [stdout]     |           ---------------------------------------------------------- rustdoc does not generate documentation for expressions
[INFO] [stdout]     |
[INFO] [stdout]     = help: use `//` for a plain comment
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::domain::table::SysRole`
[INFO] [stdout]  --> src/service/sys_user_role_service.rs:7:5
[INFO] [stdout]   |
[INFO] [stdout] 7 | use crate::domain::table::SysRole;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]   --> src/service/sys_user_role_service.rs:44:9
[INFO] [stdout]    |
[INFO] [stdout] 44 |         /// 形成角色
[INFO] [stdout]    |         ^^^^^^^^^^^^
[INFO] [stdout] 45 |         let mut user_role = SysUserRole::from(arg);
[INFO] [stdout]    |         ------------------------------------------- rustdoc does not generate documentation for statements
[INFO] [stdout]    |
[INFO] [stdout]    = help: use `//` for a plain comment
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `actix_web::guard`
[INFO] [stdout]  --> src/service/mem_service.rs:1:5
[INFO] [stdout]   |
[INFO] [stdout] 1 | use actix_web::guard;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `res`
[INFO] [stdout]  --> src/service/sys_role_service.rs:8:13
[INFO] [stdout]   |
[INFO] [stdout] 8 |             res,
[INFO] [stdout]   |             ^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unnecessary parentheses around type
[INFO] [stdout]    --> src/service/sys_role_service.rs:139:52
[INFO] [stdout]     |
[INFO] [stdout] 139 |     pub async fn remove(&self, id: &str) -> Result<(u64)> {
[INFO] [stdout]     |                                                    ^   ^
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(unused_parens)]` on by default
[INFO] [stdout] help: remove these parentheses
[INFO] [stdout]     |
[INFO] [stdout] 139 -     pub async fn remove(&self, id: &str) -> Result<(u64)> {
[INFO] [stdout] 139 +     pub async fn remove(&self, id: &str) -> Result<u64> {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `sys_role_service::SysRoleService`
[INFO] [stdout]   --> src/service/sys_res_service.rs:15:13
[INFO] [stdout]    |
[INFO] [stdout] 15 | use super::{sys_role_service::SysRoleService, CONTEXT};
[INFO] [stdout]    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]    --> src/service/sys_res_service.rs:102:9
[INFO] [stdout]     |
[INFO] [stdout] 102 |         /// 之后可以添加代码实现打印日志
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 103 |         let mut arr = vec![];
[INFO] [stdout]     |         --------------------- rustdoc does not generate documentation for statements
[INFO] [stdout]     |
[INFO] [stdout]     = help: use `//` for a plain comment
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]   --> src/service/sys_dict_service.rs:47:9
[INFO] [stdout]    |
[INFO] [stdout] 47 | /         /// 以后逻辑可能会改
[INFO] [stdout] 48 | |         ///
[INFO] [stdout]    | |___________^
[INFO] [stdout] 49 |           let res = SysDict::update_by_column(pool!(), &data, "id").await?;
[INFO] [stdout]    |           ----------------------------------------------------------------- rustdoc does not generate documentation for statements
[INFO] [stdout]    |
[INFO] [stdout]    = help: use `//` for a plain comment
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]    --> src/service/mod.rs:147:9
[INFO] [stdout]     |
[INFO] [stdout] 147 |         /// 异步测试需要单独做
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^ rustdoc does not generate documentation for macro invocations
[INFO] [stdout]     |
[INFO] [stdout]     = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `serde::de::Visitor`
[INFO] [stdout]  --> src/error.rs:6:5
[INFO] [stdout]   |
[INFO] [stdout] 6 | use serde::de::Visitor;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused imports: `Serialize`, `Serializer`
[INFO] [stdout]  --> src/error.rs:7:18
[INFO] [stdout]   |
[INFO] [stdout] 7 | use serde::ser::{Serialize, Serializer};
[INFO] [stdout]   |                  ^^^^^^^^^  ^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused imports: `Deserialize`, `Deserializer`
[INFO] [stdout]  --> src/error.rs:8:13
[INFO] [stdout]   |
[INFO] [stdout] 8 | use serde::{Deserialize, Deserializer};
[INFO] [stdout]   |             ^^^^^^^^^^^  ^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `rbatis::object_id::ObjectId`
[INFO] [stdout]  --> src/domain/dto/user.rs:1:5
[INFO] [stdout]   |
[INFO] [stdout] 1 | use rbatis::object_id::ObjectId;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::util::password_encoder::PasswordEncoder`
[INFO] [stdout]  --> src/domain/dto/user.rs:9:5
[INFO] [stdout]   |
[INFO] [stdout] 9 | use crate::util::password_encoder::PasswordEncoder;
[INFO] [stdout]   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: type `JWT_Token` should have an upper camel case name
[INFO] [stdout]  --> src/domain/vo/jwt.rs:9:12
[INFO] [stdout]   |
[INFO] [stdout] 9 | pub struct JWT_Token {
[INFO] [stdout]   |            ^^^^^^^^^ help: convert the identifier to upper camel case: `JwtToken`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]  --> src/domain/mapper/sys_user.rs:3:1
[INFO] [stdout]   |
[INFO] [stdout] 3 | / /// 后台用户表 过程宏
[INFO] [stdout] 4 | | /// 只有使用了crud！ 这个宏之后，才能生成之后的宏
[INFO] [stdout]   | |_------------------------------------------------^
[INFO] [stdout]   |   |
[INFO] [stdout]   |   rustdoc does not generate documentation for macro invocations
[INFO] [stdout]   |
[INFO] [stdout]   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]  --> src/domain/mapper/sys_user_role.rs:3:1
[INFO] [stdout]   |
[INFO] [stdout] 3 | / /// 后台用户角色表 过程宏
[INFO] [stdout] 4 | | /// 只有使用了crud！ 这个宏之后，才能生成之后的宏
[INFO] [stdout]   | |_------------------------------------------------^
[INFO] [stdout]   |   |
[INFO] [stdout]   |   rustdoc does not generate documentation for macro invocations
[INFO] [stdout]   |
[INFO] [stdout]   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused doc comment
[INFO] [stdout]  --> src/domain/mapper/sys_dict.rs:4:1
[INFO] [stdout]   |
[INFO] [stdout] 4 | / /// 系统字典表 过程宏
[INFO] [stdout] 5 | | /// 只有使用了crud！ 这个宏之后，才能生成之后的宏
[INFO] [stdout]   | |_------------------------------------------------^
[INFO] [stdout]   |   |
[INFO] [stdout]   |   rustdoc does not generate documentation for macro invocations
[INFO] [stdout]   |
[INFO] [stdout]   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unused import: `crate::service::CONTEXT`
[INFO] [stdout]   --> src/middleware/auth_actix.rs:13:5
[INFO] [stdout]    |
[INFO] [stdout] 13 | use crate::service::CONTEXT;
[INFO] [stdout]    |     ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]   --> src/service/sys_user_role_service.rs:24:13
[INFO] [stdout]    |
[INFO] [stdout] 24 |         let mut vo = CONTEXT
[INFO] [stdout]    |             ----^^
[INFO] [stdout]    |             |
[INFO] [stdout]    |             help: remove this `mut`
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(unused_mut)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]    --> src/service/sys_role_service.rs:128:13
[INFO] [stdout]     |
[INFO] [stdout] 128 |         let mut role = SysRole::from(arg);
[INFO] [stdout]     |             ----^^^^
[INFO] [stdout]     |             |
[INFO] [stdout]     |             help: remove this `mut`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]   --> src/controller/sys_dict_controller.rs:41:21
[INFO] [stdout]    |
[INFO] [stdout] 41 | pub async fn update(mut arg: web::Json<DictEditDTO>) -> impl Responder {
[INFO] [stdout]    |                     ----^^^
[INFO] [stdout]    |                     |
[INFO] [stdout]    |                     help: remove this `mut`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]   --> src/controller/sys_dict_controller.rs:49:21
[INFO] [stdout]    |
[INFO] [stdout] 49 | pub async fn remove(mut arg: web::Json<IdDTO>) -> impl Responder {
[INFO] [stdout]    |                     ----^^^
[INFO] [stdout]    |                     |
[INFO] [stdout]    |                     help: remove this `mut`
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unreachable pattern
[INFO] [stdout]   --> src/service/sys_sms_service.rs:40:13
[INFO] [stdout]    |
[INFO] [stdout] 39 |             _ => Err(Error::from("请发送验证码")),
[INFO] [stdout]    |             - matches any value
[INFO] [stdout] 40 |             Some(v) => {
[INFO] [stdout]    |             ^^^^^^^ unreachable pattern
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(unreachable_patterns)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: unreachable pattern
[INFO] [stdout]   --> src/domain/vo/role.rs:41:13
[INFO] [stdout]    |
[INFO] [stdout] 40 |             _ => None,
[INFO] [stdout]    |             - matches any value
[INFO] [stdout] 41 |             Some(arg) => Some(SysRoleVO {
[INFO] [stdout]    |             ^^^^^^^^^ unreachable pattern
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: variable `interimVO` should have a snake case name
[INFO] [stdout]    --> src/service/sys_user_service.rs:126:17
[INFO] [stdout]     |
[INFO] [stdout] 126 |         let mut interimVO = SignVO {
[INFO] [stdout]     |                 ^^^^^^^^^ help: convert the identifier to snake case: `interim_vo`
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(non_snake_case)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: 34 warnings emitted
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]     Finished test [unoptimized + debuginfo] target(s) in 1m 02s
[INFO] [stderr] warning: the following packages contain code that will be rejected by a future version of Rust: rustc-serialize v0.3.24
[INFO] [stderr] note: to see what the problems were, use the option `--future-incompat-report`, or run `cargo report future-incompatibilities --id 4`
[INFO] running `Command { std: "docker" "inspect" "3777ae4e3f55be3efe2d88d9efb31658ee474de4dc313c8d8bdf4161e2d1f1a8", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "3777ae4e3f55be3efe2d88d9efb31658ee474de4dc313c8d8bdf4161e2d1f1a8", kill_on_drop: false }`
[INFO] [stdout] 3777ae4e3f55be3efe2d88d9efb31658ee474de4dc313c8d8bdf4161e2d1f1a8
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=warn" "-e" "RUSTDOCFLAGS=--cap-lints=warn" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:2788e3201cd34a07e3172128adcd8b3090168a8e3bcc40d7c032b9dda1df7d1c" "/opt/rustwide/cargo-home/bin/cargo" "+1.75.0" "test" "--frozen", kill_on_drop: false }`
[INFO] [stdout] b2e5dd31c38adba8d3ff6f498660ae76ce5728fc04e2c3f52921435607971802
[INFO] running `Command { std: "docker" "start" "-a" "b2e5dd31c38adba8d3ff6f498660ae76ce5728fc04e2c3f52921435607971802", kill_on_drop: false }`
[INFO] [stderr] warning: trait `isEmptyString` should have an upper camel case name
[INFO] [stderr]  --> src/util/string.rs:1:11
[INFO] [stderr]   |
[INFO] [stderr] 1 | pub trait isEmptyString {
[INFO] [stderr]   |           ^^^^^^^^^^^^^ help: convert the identifier to upper camel case (notice the capitalization): `IsEmptyString`
[INFO] [stderr]   |
[INFO] [stderr]   = note: `#[warn(non_camel_case_types)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: unused doc comment
[INFO] [stderr]   --> src/controller/img_verify_controller.rs:12:5
[INFO] [stderr]    |
[INFO] [stderr] 12 |       /// 账户为空时，不输出验证码，并且报错
[INFO] [stderr]    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 13 | /     if arg.account.is_empty() {
[INFO] [stderr] 14 | |         return RespVO::<()>::from_error(&Error::from("account is empty"), "-1").resp_json();
[INFO] [stderr] 15 | |     }
[INFO] [stderr]    | |_____- rustdoc does not generate documentation for expressions
[INFO] [stderr]    |
[INFO] [stderr]    = help: use `//` for a plain comment
[INFO] [stderr]    = note: `#[warn(unused_doc_comments)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `crate::error::Error`
[INFO] [stderr]  --> src/controller/sys_role_controller.rs:6:5
[INFO] [stderr]   |
[INFO] [stderr] 6 | use crate::error::Error;
[INFO] [stderr]   |     ^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]   |
[INFO] [stderr]   = note: `#[warn(unused_imports)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: unused doc comment
[INFO] [stderr]   --> src/service/sys_user_service.rs:51:9
[INFO] [stderr]    |
[INFO] [stderr] 51 |           /// 防止爆破登录
[INFO] [stderr]    |           ^^^^^^^^^^^^^^^^
[INFO] [stderr] 52 |           // println!("sign in {:?}", arg);
[INFO] [stderr] 53 | /         let user = SysUser::select_by_column(pool!(), field_name!(SysUser.account), &arg.account)
[INFO] [stderr] 54 | |             .await?
[INFO] [stderr] 55 | |             .into_iter()
[INFO] [stderr] 56 | |             .next();
[INFO] [stderr]    | |____________________- rustdoc does not generate documentation for statements
[INFO] [stderr]    |
[INFO] [stderr]    = help: use `//` for a plain comment
[INFO] [stderr] 
[INFO] [stderr] warning: unused doc comment
[INFO] [stderr]    --> src/service/sys_user_service.rs:101:13
[INFO] [stderr]     |
[INFO] [stderr] 101 |             /// 增加重试次数
[INFO] [stderr]     |             ^^^^^^^^^^^^^^^^
[INFO] [stderr] 102 |             return Err(error.unwrap());
[INFO] [stderr]     |             -------------------------- rustdoc does not generate documentation for expressions
[INFO] [stderr]     |
[INFO] [stderr]     = help: use `//` for a plain comment
[INFO] [stderr] 
[INFO] [stderr] warning: unused doc comment
[INFO] [stderr]    --> src/service/sys_user_service.rs:118:9
[INFO] [stderr]     |
[INFO] [stderr] 118 |         /// 去除密码
[INFO] [stderr]     |         ^^^^^^^^^^^^
[INFO] [stderr] 119 |         let mut user = user.clone();
[INFO] [stderr]     |         ---------------------------- rustdoc does not generate documentation for statements
[INFO] [stderr]     |
[INFO] [stderr]     = help: use `//` for a plain comment
[INFO] [stderr] 
[INFO] [stderr] warning: unused doc comment
[INFO] [stderr]    --> src/service/sys_user_service.rs:121:9
[INFO] [stderr]     |
[INFO] [stderr] 121 |           /// 拿到ID
[INFO] [stderr]     |           ^^^^^^^^^^
[INFO] [stderr] 122 | /         let user_id = user
[INFO] [stderr] 123 | |             .id
[INFO] [stderr] 124 | |             .clone()
[INFO] [stderr] 125 | |             .ok_or_else(|| Error::from("用户数据错误，id为空"))?;
[INFO] [stderr]     | |_________________________________________________________________- rustdoc does not generate documentation for statements
[INFO] [stderr]     |
[INFO] [stderr]     = help: use `//` for a plain comment
[INFO] [stderr] 
[INFO] [stderr] warning: unused doc comment
[INFO] [stderr]    --> src/service/sys_user_service.rs:253:9
[INFO] [stderr]     |
[INFO] [stderr] 253 | /         /// 记录删除日志
[INFO] [stderr] 254 | |         /// 删除对应用户的角色
[INFO] [stderr]     | |______________________________^
[INFO] [stderr] 255 |           CONTEXT.sys_user_role_service.remove_by_user_id(id).await?;
[INFO] [stderr]     |           ---------------------------------------------------------- rustdoc does not generate documentation for expressions
[INFO] [stderr]     |
[INFO] [stderr]     = help: use `//` for a plain comment
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `crate::domain::table::SysRole`
[INFO] [stderr]  --> src/service/sys_user_role_service.rs:7:5
[INFO] [stderr]   |
[INFO] [stderr] 7 | use crate::domain::table::SysRole;
[INFO] [stderr]   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: unused doc comment
[INFO] [stderr]   --> src/service/sys_user_role_service.rs:44:9
[INFO] [stderr]    |
[INFO] [stderr] 44 |         /// 形成角色
[INFO] [stderr]    |         ^^^^^^^^^^^^
[INFO] [stderr] 45 |         let mut user_role = SysUserRole::from(arg);
[INFO] [stderr]    |         ------------------------------------------- rustdoc does not generate documentation for statements
[INFO] [stderr]    |
[INFO] [stderr]    = help: use `//` for a plain comment
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `actix_web::guard`
[INFO] [stderr]  --> src/service/mem_service.rs:1:5
[INFO] [stderr]   |
[INFO] [stderr] 1 | use actix_web::guard;
[INFO] [stderr]   |     ^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `res`
[INFO] [stderr]  --> src/service/sys_role_service.rs:8:13
[INFO] [stderr]   |
[INFO] [stderr] 8 |             res,
[INFO] [stderr]   |             ^^^
[INFO] [stderr] 
[INFO] [stderr] warning: unnecessary parentheses around type
[INFO] [stderr]    --> src/service/sys_role_service.rs:139:52
[INFO] [stderr]     |
[INFO] [stderr] 139 |     pub async fn remove(&self, id: &str) -> Result<(u64)> {
[INFO] [stderr]     |                                                    ^   ^
[INFO] [stderr]     |
[INFO] [stderr]     = note: `#[warn(unused_parens)]` on by default
[INFO] [stderr] help: remove these parentheses
[INFO] [stderr]     |
[INFO] [stderr] 139 -     pub async fn remove(&self, id: &str) -> Result<(u64)> {
[INFO] [stderr] 139 +     pub async fn remove(&self, id: &str) -> Result<u64> {
[INFO] [stderr]     |
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `sys_role_service::SysRoleService`
[INFO] [stderr]   --> src/service/sys_res_service.rs:15:13
[INFO] [stderr]    |
[INFO] [stderr] 15 | use super::{sys_role_service::SysRoleService, CONTEXT};
[INFO] [stderr]    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: unused doc comment
[INFO] [stderr]    --> src/service/sys_res_service.rs:102:9
[INFO] [stderr]     |
[INFO] [stderr] 102 |         /// 之后可以添加代码实现打印日志
[INFO] [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 103 |         let mut arr = vec![];
[INFO] [stderr]     |         --------------------- rustdoc does not generate documentation for statements
[INFO] [stderr]     |
[INFO] [stderr]     = help: use `//` for a plain comment
[INFO] [stderr] 
[INFO] [stderr] warning: unused doc comment
[INFO] [stderr]   --> src/service/sys_dict_service.rs:47:9
[INFO] [stderr]    |
[INFO] [stderr] 47 | /         /// 以后逻辑可能会改
[INFO] [stderr] 48 | |         ///
[INFO] [stderr]    | |___________^
[INFO] [stderr] 49 |           let res = SysDict::update_by_column(pool!(), &data, "id").await?;
[INFO] [stderr]    |           ----------------------------------------------------------------- rustdoc does not generate documentation for statements
[INFO] [stderr]    |
[INFO] [stderr]    = help: use `//` for a plain comment
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `super::*`
[INFO] [stderr]    --> src/service/mod.rs:141:9
[INFO] [stderr]     |
[INFO] [stderr] 141 |     use super::*;
[INFO] [stderr]     |         ^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `serde::de::Visitor`
[INFO] [stderr]  --> src/error.rs:6:5
[INFO] [stderr]   |
[INFO] [stderr] 6 | use serde::de::Visitor;
[INFO] [stderr]   |     ^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: unused imports: `Serialize`, `Serializer`
[INFO] [stderr]  --> src/error.rs:7:18
[INFO] [stderr]   |
[INFO] [stderr] 7 | use serde::ser::{Serialize, Serializer};
[INFO] [stderr]   |                  ^^^^^^^^^  ^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: unused imports: `Deserialize`, `Deserializer`
[INFO] [stderr]  --> src/error.rs:8:13
[INFO] [stderr]   |
[INFO] [stderr] 8 | use serde::{Deserialize, Deserializer};
[INFO] [stderr]   |             ^^^^^^^^^^^  ^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `rbatis::object_id::ObjectId`
[INFO] [stderr]  --> src/domain/dto/user.rs:1:5
[INFO] [stderr]   |
[INFO] [stderr] 1 | use rbatis::object_id::ObjectId;
[INFO] [stderr]   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `crate::util::password_encoder::PasswordEncoder`
[INFO] [stderr]  --> src/domain/dto/user.rs:9:5
[INFO] [stderr]   |
[INFO] [stderr] 9 | use crate::util::password_encoder::PasswordEncoder;
[INFO] [stderr]   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: type `JWT_Token` should have an upper camel case name
[INFO] [stderr]  --> src/domain/vo/jwt.rs:9:12
[INFO] [stderr]   |
[INFO] [stderr] 9 | pub struct JWT_Token {
[INFO] [stderr]   |            ^^^^^^^^^ help: convert the identifier to upper camel case: `JwtToken`
[INFO] [stderr] 
[INFO] [stderr] warning: unused doc comment
[INFO] [stderr]  --> src/domain/mapper/sys_user.rs:3:1
[INFO] [stderr]   |
[INFO] [stderr] 3 | / /// 后台用户表 过程宏
[INFO] [stderr] 4 | | /// 只有使用了crud！ 这个宏之后，才能生成之后的宏
[INFO] [stderr]   | |_------------------------------------------------^
[INFO] [stderr]   |   |
[INFO] [stderr]   |   rustdoc does not generate documentation for macro invocations
[INFO] [stderr]   |
[INFO] [stderr]   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion
[INFO] [stderr] 
[INFO] [stderr] warning: unused doc comment
[INFO] [stderr]  --> src/domain/mapper/sys_user_role.rs:3:1
[INFO] [stderr]   |
[INFO] [stderr] 3 | / /// 后台用户角色表 过程宏
[INFO] [stderr] 4 | | /// 只有使用了crud！ 这个宏之后，才能生成之后的宏
[INFO] [stderr]   | |_------------------------------------------------^
[INFO] [stderr]   |   |
[INFO] [stderr]   |   rustdoc does not generate documentation for macro invocations
[INFO] [stderr]   |
[INFO] [stderr]   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion
[INFO] [stderr] 
[INFO] [stderr] warning: unused doc comment
[INFO] [stderr]  --> src/domain/mapper/sys_dict.rs:4:1
[INFO] [stderr]   |
[INFO] [stderr] 4 | / /// 系统字典表 过程宏
[INFO] [stderr] 5 | | /// 只有使用了crud！ 这个宏之后，才能生成之后的宏
[INFO] [stderr]   | |_------------------------------------------------^
[INFO] [stderr]   |   |
[INFO] [stderr]   |   rustdoc does not generate documentation for macro invocations
[INFO] [stderr]   |
[INFO] [stderr]   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `crate::domain::table::enums::LoginCheck`
[INFO] [stderr]    --> src/domain/table/tables.rs:103:9
[INFO] [stderr]     |
[INFO] [stderr] 103 |     use crate::domain::table::enums::LoginCheck;
[INFO] [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `super::*`
[INFO] [stderr]    --> src/domain/table/tables.rs:105:9
[INFO] [stderr]     |
[INFO] [stderr] 105 |     use super::*;
[INFO] [stderr]     |         ^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: unused import: `crate::service::CONTEXT`
[INFO] [stderr]   --> src/middleware/auth_actix.rs:13:5
[INFO] [stderr]    |
[INFO] [stderr] 13 | use crate::service::CONTEXT;
[INFO] [stderr]    |     ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] warning: variable does not need to be mutable
[INFO] [stderr]   --> src/service/sys_user_role_service.rs:24:13
[INFO] [stderr]    |
[INFO] [stderr] 24 |         let mut vo = CONTEXT
[INFO] [stderr]    |             ----^^
[INFO] [stderr]    |             |
[INFO] [stderr]    |             help: remove this `mut`
[INFO] [stderr]    |
[INFO] [stderr]    = note: `#[warn(unused_mut)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: variable does not need to be mutable
[INFO] [stderr]    --> src/service/sys_role_service.rs:128:13
[INFO] [stderr]     |
[INFO] [stderr] 128 |         let mut role = SysRole::from(arg);
[INFO] [stderr]     |             ----^^^^
[INFO] [stderr]     |             |
[INFO] [stderr]     |             help: remove this `mut`
[INFO] [stderr] 
[INFO] [stderr] warning: variable does not need to be mutable
[INFO] [stderr]   --> src/controller/sys_dict_controller.rs:41:21
[INFO] [stderr]    |
[INFO] [stderr] 41 | pub async fn update(mut arg: web::Json<DictEditDTO>) -> impl Responder {
[INFO] [stderr]    |                     ----^^^
[INFO] [stderr]    |                     |
[INFO] [stderr]    |                     help: remove this `mut`
[INFO] [stderr] 
[INFO] [stderr] warning: variable does not need to be mutable
[INFO] [stderr]   --> src/controller/sys_dict_controller.rs:49:21
[INFO] [stderr]    |
[INFO] [stderr] 49 | pub async fn remove(mut arg: web::Json<IdDTO>) -> impl Responder {
[INFO] [stderr]    |                     ----^^^
[INFO] [stderr]    |                     |
[INFO] [stderr]    |                     help: remove this `mut`
[INFO] [stderr] 
[INFO] [stderr] warning: unreachable pattern
[INFO] [stderr]   --> src/service/sys_sms_service.rs:40:13
[INFO] [stderr]    |
[INFO] [stderr] 39 |             _ => Err(Error::from("请发送验证码")),
[INFO] [stderr]    |             - matches any value
[INFO] [stderr] 40 |             Some(v) => {
[INFO] [stderr]    |             ^^^^^^^ unreachable pattern
[INFO] [stderr]    |
[INFO] [stderr]    = note: `#[warn(unreachable_patterns)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: unreachable pattern
[INFO] [stderr]   --> src/domain/vo/role.rs:41:13
[INFO] [stderr]    |
[INFO] [stderr] 40 |             _ => None,
[INFO] [stderr]    |             - matches any value
[INFO] [stderr] 41 |             Some(arg) => Some(SysRoleVO {
[INFO] [stderr]    |             ^^^^^^^^^ unreachable pattern
[INFO] [stderr] 
[INFO] [stderr] warning: variable `interimVO` should have a snake case name
[INFO] [stderr]    --> src/service/sys_user_service.rs:126:17
[INFO] [stderr]     |
[INFO] [stderr] 126 |         let mut interimVO = SignVO {
[INFO] [stderr]     |                 ^^^^^^^^^ help: convert the identifier to snake case: `interim_vo`
[INFO] [stderr]     |
[INFO] [stderr]     = note: `#[warn(non_snake_case)]` on by default
[INFO] [stderr] 
[INFO] [stderr] warning: unused doc comment
[INFO] [stderr]    --> src/service/mod.rs:147:9
[INFO] [stderr]     |
[INFO] [stderr] 147 |         /// 异步测试需要单独做
[INFO] [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^ rustdoc does not generate documentation for macro invocations
[INFO] [stderr]     |
[INFO] [stderr]     = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion
[INFO] [stderr] 
[INFO] [stderr] warning: `backend` (lib) generated 36 warnings (run `cargo fix --lib -p backend` to apply 19 suggestions)
[INFO] [stderr] warning: `backend` (lib test) generated 34 warnings (33 duplicates)
[INFO] [stderr]     Finished test [unoptimized + debuginfo] target(s) in 0.17s
[INFO] [stderr] warning: the following packages contain code that will be rejected by a future version of Rust: rustc-serialize v0.3.24
[INFO] [stderr] note: to see what the problems were, use the option `--future-incompat-report`, or run `cargo report future-incompatibilities --id 4`
[INFO] [stderr]      Running unittests src/lib.rs (/opt/rustwide/target/debug/deps/backend-fc4a8c113916e3c6)
[INFO] [stdout] 
[INFO] [stdout] running 5 tests
[INFO] [stdout] test util::password_encoder::test::test_encode ... ok
[INFO] [stdout] test domain::table::tables::test::convert ... ok
[INFO] [stdout] test domain::vo::jwt::test::test_jwt ... ok
[INFO] [stdout] test service::test::test_link_database ... ok
[INFO] [stdout] test util::password_encoder::test::test_verify ... FAILED
[INFO] [stdout] 
[INFO] [stdout] failures:
[INFO] [stdout] 
[INFO] [stdout] ---- util::password_encoder::test::test_verify stdout ----
[INFO] [stdout] thread 'util::password_encoder::test::test_verify' panicked at src/util/password_encoder.rs:33:9:
[INFO] [stdout] assertion failed: PasswordEncoder::verify("123456", &encode_str)
[INFO] [stdout] stack backtrace:
[INFO] [stdout]    0:     0x560dcac40c2c - std::backtrace_rs::backtrace::libunwind::trace::ha637c64ce894333a
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/std/src/../../backtrace/src/backtrace/libunwind.rs:104:5
[INFO] [stdout]    1:     0x560dcac40c2c - std::backtrace_rs::backtrace::trace_unsynchronized::h47f62dea28e0c88d
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/std/src/../../backtrace/src/backtrace/mod.rs:66:5
[INFO] [stdout]    2:     0x560dcac40c2c - std::sys_common::backtrace::_print_fmt::h9eef0abe20ede486
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/std/src/sys_common/backtrace.rs:67:5
[INFO] [stdout]    3:     0x560dcac40c2c - <std::sys_common::backtrace::_print::DisplayBacktrace as core::fmt::Display>::fmt::hed7f999df88cc644
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/std/src/sys_common/backtrace.rs:44:22
[INFO] [stdout]    4:     0x560dcac6d3c0 - core::fmt::rt::Argument::fmt::h1539a9308b8d058d
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/core/src/fmt/rt.rs:142:9
[INFO] [stdout]    5:     0x560dcac6d3c0 - core::fmt::write::h3a39390d8560d9c9
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/core/src/fmt/mod.rs:1120:17
[INFO] [stdout]    6:     0x560dcac3de3f - std::io::Write::write_fmt::h040b369f3a0f9cbc
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/std/src/io/mod.rs:1762:15
[INFO] [stdout]    7:     0x560dcac40a14 - std::sys_common::backtrace::_print::h894006fb5c6f3d45
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/std/src/sys_common/backtrace.rs:47:5
[INFO] [stdout]    8:     0x560dcac40a14 - std::sys_common::backtrace::print::h23a2d212c6fff936
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/std/src/sys_common/backtrace.rs:34:9
[INFO] [stdout]    9:     0x560dcac426d7 - std::panicking::default_hook::{{closure}}::h8a1d2ee00185001a
[INFO] [stdout]   10:     0x560dcac423c3 - std::panicking::default_hook::h6038f2eba384e475
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/std/src/panicking.rs:289:9
[INFO] [stdout]   11:     0x560dcaa0b087 - <alloc::boxed::Box<F,A> as core::ops::function::Fn<Args>>::call::h0ad024c9bdc6d768
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/alloc/src/boxed.rs:2021:9
[INFO] [stdout]   12:     0x560dcaa0b087 - test::test_main::{{closure}}::h7500b54257359db6
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/test/src/lib.rs:138:21
[INFO] [stdout]   13:     0x560dcac42ce8 - <alloc::boxed::Box<F,A> as core::ops::function::Fn<Args>>::call::h1f8f335eaa9cfaee
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/alloc/src/boxed.rs:2021:9
[INFO] [stdout]   14:     0x560dcac42ce8 - std::panicking::rust_panic_with_hook::h2b5517d590cab22e
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/std/src/panicking.rs:783:13
[INFO] [stdout]   15:     0x560dcac42a09 - std::panicking::begin_panic_handler::{{closure}}::h233112c06e0ef43e
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/std/src/panicking.rs:649:13
[INFO] [stdout]   16:     0x560dcac410f6 - std::sys_common::backtrace::__rust_end_short_backtrace::h6e893f24d7ebbff8
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/std/src/sys_common/backtrace.rs:170:18
[INFO] [stdout]   17:     0x560dcac427a2 - rust_begin_unwind
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/std/src/panicking.rs:645:5
[INFO] [stdout]   18:     0x560dca94f405 - core::panicking::panic_fmt::hbf0e066aabfa482c
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/core/src/panicking.rs:72:14
[INFO] [stdout]   19:     0x560dca94f4a3 - core::panicking::panic::h195fc2a96298d4c3
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/core/src/panicking.rs:127:5
[INFO] [stdout]   20:     0x560dca987ed5 - backend::util::password_encoder::test::test_verify::hd6348e8af2c4e8c5
[INFO] [stdout]                                at /opt/rustwide/workdir/src/util/password_encoder.rs:33:9
[INFO] [stdout]   21:     0x560dca987de7 - backend::util::password_encoder::test::test_verify::{{closure}}::hdb658e2e2dd12daa
[INFO] [stdout]                                at /opt/rustwide/workdir/src/util/password_encoder.rs:30:21
[INFO] [stdout]   22:     0x560dca956886 - core::ops::function::FnOnce::call_once::h951c828c48d77225
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/core/src/ops/function.rs:250:5
[INFO] [stdout]   23:     0x560dcaa106df - core::ops::function::FnOnce::call_once::h2b5d431d5046312d
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/core/src/ops/function.rs:250:5
[INFO] [stdout]   24:     0x560dcaa106df - test::__rust_begin_short_backtrace::h7714669af176e207
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/test/src/lib.rs:628:18
[INFO] [stdout]   25:     0x560dcaa0f6f5 - test::run_test_in_process::{{closure}}::h85218797dcbcec12
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/test/src/lib.rs:651:60
[INFO] [stdout]   26:     0x560dcaa0f6f5 - <core::panic::unwind_safe::AssertUnwindSafe<F> as core::ops::function::FnOnce<()>>::call_once::h76c106ea31c14d7b
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/core/src/panic/unwind_safe.rs:272:9
[INFO] [stdout]   27:     0x560dcaa0f6f5 - std::panicking::try::do_call::h3bd5d0f6620ee946
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/std/src/panicking.rs:552:40
[INFO] [stdout]   28:     0x560dcaa0f6f5 - std::panicking::try::h232e535e4744fe31
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/std/src/panicking.rs:516:19
[INFO] [stdout]   29:     0x560dcaa0f6f5 - std::panic::catch_unwind::h3ce3bd6ca8dbac68
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/std/src/panic.rs:142:14
[INFO] [stdout]   30:     0x560dcaa0f6f5 - test::run_test_in_process::hc97b257c9621286a
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/test/src/lib.rs:651:27
[INFO] [stdout]   31:     0x560dcaa0f6f5 - test::run_test::{{closure}}::h2aa798823a438d38
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/test/src/lib.rs:574:43
[INFO] [stdout]   32:     0x560dca9d79b6 - test::run_test::{{closure}}::h87d231c78fb59832
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/test/src/lib.rs:602:41
[INFO] [stdout]   33:     0x560dca9d79b6 - std::sys_common::backtrace::__rust_begin_short_backtrace::he6df152596625789
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/std/src/sys_common/backtrace.rs:154:18
[INFO] [stdout]   34:     0x560dca9dca67 - std::thread::Builder::spawn_unchecked_::{{closure}}::{{closure}}::ha94be15d1e0acf36
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/std/src/thread/mod.rs:529:17
[INFO] [stdout]   35:     0x560dca9dca67 - <core::panic::unwind_safe::AssertUnwindSafe<F> as core::ops::function::FnOnce<()>>::call_once::h9dc6bd6372f16606
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/core/src/panic/unwind_safe.rs:272:9
[INFO] [stdout]   36:     0x560dca9dca67 - std::panicking::try::do_call::h9057517f80303cd4
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/std/src/panicking.rs:552:40
[INFO] [stdout]   37:     0x560dca9dca67 - std::panicking::try::he3a30b11ee45340c
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/std/src/panicking.rs:516:19
[INFO] [stdout]   38:     0x560dca9dca67 - std::panic::catch_unwind::h410458cfd3528b8b
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/std/src/panic.rs:142:14
[INFO] [stdout]   39:     0x560dca9dca67 - std::thread::Builder::spawn_unchecked_::{{closure}}::h72ac3bdb567b737b
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/std/src/thread/mod.rs:528:30
[INFO] [stdout]   40:     0x560dca9dca67 - core::ops::function::FnOnce::call_once{{vtable.shim}}::h38f34da3654a8344
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/core/src/ops/function.rs:250:5
[INFO] [stdout]   41:     0x560dcac477e5 - <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once::hc7eafaff61e32df9
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/alloc/src/boxed.rs:2007:9
[INFO] [stdout]   42:     0x560dcac477e5 - <alloc::boxed::Box<F,A> as core::ops::function::FnOnce<Args>>::call_once::h6ba4a5de48dd2304
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/alloc/src/boxed.rs:2007:9
[INFO] [stdout]   43:     0x560dcac477e5 - std::sys::unix::thread::Thread::new::thread_start::he469335aef763e45
[INFO] [stdout]                                at /rustc/82e1608dfa6e0b5569232559e3d385fea5a93112/library/std/src/sys/unix/thread.rs:108:17
[INFO] [stdout]   44:     0x7fc0b5c98ac3 - <unknown>
[INFO] [stdout]   45:     0x7fc0b5d29bf4 - __clone
[INFO] [stdout]   46:                0x0 - <unknown>
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] failures:
[INFO] [stdout]     util::password_encoder::test::test_verify
[INFO] [stdout] 
[INFO] [stdout] test result: FAILED. 4 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.11s
[INFO] [stdout] 
[INFO] [stderr] error: test failed, to rerun pass `--lib`
[INFO] running `Command { std: "docker" "inspect" "b2e5dd31c38adba8d3ff6f498660ae76ce5728fc04e2c3f52921435607971802", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "b2e5dd31c38adba8d3ff6f498660ae76ce5728fc04e2c3f52921435607971802", kill_on_drop: false }`
[INFO] [stdout] b2e5dd31c38adba8d3ff6f498660ae76ce5728fc04e2c3f52921435607971802