generate rng with iterator

Author: fakeshadow

frameworks/Rust/xitca-web/Cargo.lock

@@ -35,19 +35,19 @@ impl Client {
     }
 
     pub async fn get_worlds(&self, num: u16) -> HandleResult<Vec<World>> {
-        let len = num as usize;
-
         let mut conn = self.pool.get().await?;
         let stmt = WORLD_STMT.execute(&mut conn).await?;
 
         let mut res = {
             let (ref mut rng, ref mut buf) = *self.shared.borrow_mut();
-            let mut pipe = Pipeline::with_capacity_from_buf(len, buf);
-            (0..num).try_for_each(|_| stmt.bind([rng.gen_id()]).query(&mut pipe))?;
+            let mut pipe = Pipeline::with_capacity_from_buf(num as _, buf);
+            rng.gen_multi()
+                .take(num as _)
+                .try_for_each(|id| stmt.bind([id]).query(&mut pipe))?;
             pipe.query(&conn.consume())?
         };
 
-        let mut worlds = Vec::with_capacity(len);
+        let mut worlds = Vec::with_capacity(num as _);
 
         while let Some(mut item) = res.try_next().await? {
             let row = item.try_next().await?.ok_or_else(not_found)?;
@@ -58,28 +58,26 @@ impl Client {
     }
 
     pub async fn update(&self, num: u16) -> HandleResult<Vec<World>> {
-        let len = num as usize;
-
         let mut conn = self.pool.get().await?;
         let world_stmt = WORLD_STMT.execute(&mut conn).await?;
         let update_stmt = UPDATE_BATCH_STMT.execute(&mut conn).await?;
 
         let (mut res, worlds) = {
             let (ref mut rng, ref mut buf) = *self.shared.borrow_mut();
-            let mut pipe = Pipeline::with_capacity_from_buf(len + 1, buf);
-
-            let (mut params, worlds) = core::iter::repeat_with(|| {
-                let id = rng.gen_id();
-                let rand = rng.gen_id();
-                world_stmt.bind([id]).query(&mut pipe)?;
-                HandleResult::Ok(((id, rand), World::new(id, rand)))
-            })
-            .take(len)
-            .collect::<Result<(Vec<_>, Vec<_>), _>>()?;
-
-            params.sort();
-            let (ids, rngs) = params.into_iter().collect::<(Vec<_>, Vec<_>)>();
-
+            let mut pipe = Pipeline::with_capacity_from_buf((num + 1) as _, buf);
+
+            let mut ids = rng.gen_multi().take(num as _).collect::<Vec<_>>();
+            ids.sort();
+
+            let (rngs, worlds) = ids
+                .iter()
+                .cloned()
+                .zip(rng.gen_multi())
+                .map(|(id, rand)| {
+                    world_stmt.bind([id]).query(&mut pipe)?;
+                    HandleResult::Ok((rand, World::new(id, rand)))
+                })
+                .collect::<HandleResult<(Vec<_>, Vec<_>)>>()?;
             update_stmt.bind([&ids, &rngs]).query(&mut pipe)?;
             (pipe.query(&conn.consume())?, worlds)
         };

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

@@ -88,7 +88,7 @@ impl Client {
                 HandleResult::Ok(((id, rand), World::new(id, rand)))
             })
             .take(len)
-            .collect::<Result<(Vec<_>, Vec<_>), _>>()?;
+            .collect::<HandleResult<(Vec<_>, Vec<_>)>>()?;
 
             params.sort();
 

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

@@ -1,6 +1,6 @@
 #![allow(dead_code)]
 
-use rand::{Rng, SeedableRng, rngs::SmallRng};
+use rand::{Rng, SeedableRng, distr::Uniform, rngs::SmallRng};
 use xitca_http::{bytes::BytesMut, http::header::HeaderValue};
 
 pub trait QueryParse {
@@ -57,4 +57,9 @@ impl Rand {
     pub fn gen_id(&mut self) -> i32 {
         self.0.random_range(1..=10000)
     }
+
+    #[inline]
+    pub fn gen_multi(&mut self) -> impl Iterator<Item = i32> {
+        (&mut self.0).sample_iter(Uniform::new(1, 10001).unwrap())
+    }
 }