[xitca-web] bug fix and improvements (#9272)

* [xitca-web] bug fix and improvements

* comment fix

Author: fakeshadow

frameworks/Rust/xitca-web/Cargo.lock

@@ -85,7 +85,7 @@ mimalloc = { version = "0.1", default-features = false, optional = true }
 # stuff can not be used or not needed in wasi target
 [target.'cfg(not(target_family = "wasm"))'.dependencies]
 futures-core = { version = "0.3", default-features = false }
-nanorand = { version = "0.7", default-features = false, features = ["tls"] }
+rand = { version = "0.8", features = ["small_rng"] }
 tokio = "1"
 
 [profile.release]
@@ -95,5 +95,5 @@ codegen-units = 1
 panic = "abort"
 
 [patch.crates-io]
-xitca-postgres = { git = "https://github.com/HFQR/xitca-web.git", rev = "9835c0b" }
+xitca-postgres = { git = "https://github.com/HFQR/xitca-web.git", rev = "0cda225" }
 mio = { git = "https://github.com/fakeshadow/mio", rev = "9bae6012b7ecfc6083350785f71a5e8265358178" }

frameworks/Rust/xitca-web/Cargo.toml

@@ -1,11 +1,12 @@
-use std::fmt::Write;
+// clippy is dumb and have no idea what should be lazy or not
+#![allow(clippy::unnecessary_lazy_evaluations)]
 
 use xitca_io::bytes::BytesMut;
-use xitca_postgres::{pipeline::Pipeline, AsyncLendingIterator, Pool, Type};
+use xitca_postgres::{pipeline::Pipeline, pool::Pool, AsyncLendingIterator, Type};
 
 use super::{
     ser::{Fortune, Fortunes, World},
-    util::{HandleResult, Rand, DB_URL},
+    util::{bulk_update_gen, HandleResult, Rand, DB_URL},
 };
 
 pub struct Client {
@@ -28,19 +29,14 @@ const WORLD_SQL: &str = "SELECT * FROM world WHERE id=$1";
 const WORLD_SQL_TYPES: &[Type] = &[Type::INT4];
 
 fn update_query(num: usize) -> Box<str> {
-    const PREFIX: &str = "UPDATE world SET randomNumber = w.r FROM (VALUES ";
-    const SUFFIX: &str = ") AS w (i,r) WHERE world.id = w.i";
-
-    let (_, mut query) = (1..=num).fold((1, String::from(PREFIX)), |(idx, mut query), _| {
-        write!(query, "(${}::int,${}::int),", idx, idx + 1).unwrap();
-        (idx + 2, query)
-    });
-
-    query.pop();
-
-    query.push_str(SUFFIX);
-
-    query.into_boxed_str()
+    bulk_update_gen(|query| {
+        use std::fmt::Write;
+        (1..=num).fold((1, query), |(idx, query), _| {
+            write!(query, "(${}::int,${}::int),", idx, idx + 1).unwrap();
+            (idx + 2, query)
+        });
+    })
+    .into_boxed_str()
 }
 
 pub async fn create() -> HandleResult<Client> {
@@ -50,14 +46,7 @@ pub async fn create() -> HandleResult<Client> {
 
     let updates = core::iter::once(Box::from(""))
         .chain((1..=500).map(update_query))
-        .collect::<Box<[Box<str>]>>();
-
-    {
-        let mut conn = pool.get().await?;
-        for update in updates.iter().skip(1) {
-            conn.prepare(update, &[]).await?;
-        }
-    }
+        .collect();
 
     Ok(Client {
         pool,
@@ -120,7 +109,7 @@ impl Client {
 
         let mut conn = self.pool.get().await?;
         let world_stmt = conn.prepare(WORLD_SQL, WORLD_SQL_TYPES).await?;
-        let update_stmt = conn.prepare(&update, &[]).await?;
+        let update_stmt = conn.prepare(update, &[]).await?;
 
         let mut params = Vec::with_capacity(len);
 
@@ -169,8 +158,8 @@ impl Client {
     }
 }
 
-fn sort_update_params(params: &Vec<[i32; 2]>) -> impl ExactSizeIterator<Item = i32> {
-    let mut params = params.clone();
+fn sort_update_params(params: &[[i32; 2]]) -> impl ExactSizeIterator<Item = i32> {
+    let mut params = params.to_owned();
     params.sort_by(|a, b| a[0].cmp(&b[0]));
 
     struct ParamIter<I>(I);

frameworks/Rust/xitca-web/src/db.rs

@@ -1,10 +1,13 @@
-use std::sync::{Arc, Mutex};
+use std::{
+    io,
+    sync::{Arc, Mutex},
+};
 
 use diesel::{prelude::*, r2d2};
 
 use crate::{
     ser::{Fortune, Fortunes, World},
-    util::{Error, HandleResult, Rand, DB_URL},
+    util::{bulk_update_gen, Error, HandleResult, Rand, DB_URL},
 };
 
 pub type Pool = Arc<_Pool>;
@@ -14,15 +17,15 @@ pub struct _Pool {
     rng: Mutex<Rand>,
 }
 
-pub fn create() -> std::io::Result<Arc<_Pool>> {
+pub fn create() -> io::Result<Arc<_Pool>> {
     r2d2::Builder::new()
         .max_size(100)
         .min_idle(Some(100))
         .test_on_check_out(false)
         .idle_timeout(None)
         .max_lifetime(None)
         .build(r2d2::ConnectionManager::new(DB_URL))
-        .map_err(std::io::Error::other)
+        .map_err(io::Error::other)
         .map(|pool| {
             Arc::new(_Pool {
                 pool,
@@ -65,33 +68,32 @@ impl _Pool {
     pub fn update(&self, num: u16) -> HandleResult<Vec<World>> {
         use crate::schema::world::dsl::*;
 
+        let mut rngs = {
+            let mut rng = self.rng.lock().unwrap();
+            (0..num).map(|_| (rng.gen_id(), rng.gen_id())).collect::<Vec<_>>()
+        };
+
+        rngs.sort_by(|(a, _), (b, _)| a.cmp(b));
+
         let mut worlds = {
             let mut conn = self.pool.get()?;
-            let worlds = (0..num)
-                .map(|_| {
-                    let mut rng = self.rng.lock().unwrap();
-                    let w_id = rng.gen_id();
-                    let r_id = rng.gen_id();
-                    drop(rng);
+
+            let worlds = rngs
+                .iter()
+                .map(|(w_id, num)| {
                     world
                         .filter(id.eq(w_id))
                         .load::<World>(&mut conn)?
                         .pop()
                         .map(|mut w| {
-                            w.randomnumber = r_id;
+                            w.randomnumber = *num;
                             w
                         })
                         .ok_or_else(not_found)
                 })
                 .collect::<HandleResult<Vec<_>>>()?;
 
-            worlds.iter().try_for_each(|w| {
-                diesel::update(world)
-                    .filter(id.eq(w.id))
-                    .set(randomnumber.eq(w.randomnumber))
-                    .execute(&mut conn)
-                    .map(|_| ())
-            })?;
+            diesel::sql_query(update_query(&rngs)).execute(&mut conn)?;
 
             worlds
         };
@@ -115,3 +117,14 @@ impl _Pool {
         Ok(Fortunes::new(items))
     }
 }
+
+// diesel does not support high level bulk update api. use raw sql to bypass the limitation.
+// relate discussion: https://github.com/diesel-rs/diesel/discussions/2879
+fn update_query(ids: &[(i32, i32)]) -> String {
+    bulk_update_gen(|query| {
+        use std::fmt::Write;
+        ids.iter().for_each(|(w_id, num)| {
+            write!(query, "({}::int,{}::int),", w_id, num).unwrap();
+        });
+    })
+}