dep update

Author: fakeshadow

frameworks/Rust/xitca-web/Cargo.lock

@@ -95,8 +95,7 @@ codegen-units = 1
 panic = "abort"
 
 [patch.crates-io]
-xitca-postgres = { git = "https://github.com/HFQR/xitca-web.git", rev = "7e6534f" }
-xitca-postgres-diesel = { git = "https://github.com/fakeshadow/xitca-postgres-diesel", rev = "8addeca" }
+xitca-postgres-diesel = { git = "https://github.com/fakeshadow/xitca-postgres-diesel", rev = "5fb1e6d5f0f20cfb5ef0833a44dc209b1f46f1df" }
 
 diesel-async = { git = "https://github.com/weiznich/diesel_async", rev = "5b8262b" }
 mio = { git = "https://github.com/fakeshadow/mio", rev = "9bae6012b7ecfc6083350785f71a5e8265358178" }

frameworks/Rust/xitca-web/Cargo.toml

@@ -1,8 +1,14 @@
-// clippy is dumb and have no idea what should be lazy or not
-#![allow(clippy::unnecessary_lazy_evaluations)]
+use std::cell::RefCell;
 
 use xitca_io::bytes::BytesMut;
-use xitca_postgres::{pipeline::Pipeline, pool::Pool, types::Type, AsyncLendingIterator};
+use xitca_postgres::{
+    iter::AsyncLendingIterator,
+    pipeline::Pipeline,
+    pool::Pool,
+    statement::{Statement, StatementNamed},
+    types::Type,
+    Execute, ExecuteMut,
+};
 
 use super::{
     ser::{Fortune, Fortunes, World},
@@ -11,17 +17,14 @@ use super::{
 
 pub struct Client {
     pool: Pool,
-    shared: std::cell::RefCell<Shared>,
+    shared: RefCell<Shared>,
     updates: Box<[Box<str>]>,
 }
 
 type Shared = (Rand, BytesMut);
 
-const FORTUNE_SQL: &str = "SELECT * FROM fortune";
-const FORTUNE_SQL_TYPES: &[Type] = &[];
-
-const WORLD_SQL: &str = "SELECT * FROM world WHERE id=$1";
-const WORLD_SQL_TYPES: &[Type] = &[Type::INT4];
+const FORTUNE_STMT: StatementNamed = Statement::named("SELECT * FROM fortune", &[]);
+const WORLD_STMT: StatementNamed = Statement::named("SELECT * FROM world WHERE id=$1", &[Type::INT4]);
 
 fn update_query(num: usize) -> Box<str> {
     bulk_update_gen(|query| {
@@ -35,10 +38,9 @@ fn update_query(num: usize) -> Box<str> {
 }
 
 pub async fn create() -> HandleResult<Client> {
-    let pool = Pool::builder(DB_URL).capacity(1).build()?;
     Ok(Client {
-        pool,
-        shared: std::cell::RefCell::new((Rand::default(), BytesMut::new())),
+        pool: Pool::builder(DB_URL).capacity(1).build()?,
+        shared: RefCell::new((Rand::default(), BytesMut::new())),
         updates: core::iter::once(Box::from(""))
             .chain((1..=500).map(update_query))
             .collect(),
@@ -48,24 +50,24 @@ pub async fn create() -> HandleResult<Client> {
 impl Client {
     pub async fn get_world(&self) -> HandleResult<World> {
         let mut conn = self.pool.get().await?;
-        let stmt = conn.prepare_cache(WORLD_SQL, WORLD_SQL_TYPES).await?;
+        let stmt = WORLD_STMT.execute_mut(&mut conn).await?;
         let id = self.shared.borrow_mut().0.gen_id();
-        let mut res = conn.consume().query(stmt.bind([id]))?;
-        let row = res.try_next().await?.ok_or_else(|| "World does not exist")?;
+        let mut res = stmt.bind([id]).query(&conn.consume()).await?;
+        let row = res.try_next().await?.ok_or("request World does not exist")?;
         Ok(World::new(row.get(0), row.get(1)))
     }
 
     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 = conn.prepare_cache(WORLD_SQL, WORLD_SQL_TYPES).await?;
+        let stmt = WORLD_STMT.execute_mut(&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(|_| pipe.query(stmt.bind([rng.gen_id()])))?;
-            conn.consume().pipeline(pipe)?
+            (0..num).try_for_each(|_| stmt.bind([rng.gen_id()]).query_mut(&mut pipe))?;
+            pipe.query(&conn.consume())?
         };
 
         let mut worlds = Vec::with_capacity(len);
@@ -82,11 +84,10 @@ impl Client {
     pub async fn update(&self, num: u16) -> HandleResult<Vec<World>> {
         let len = num as usize;
 
-        let update = self.updates.get(len).ok_or_else(|| "num out of bound")?;
-
+        let update = self.updates.get(len).ok_or("request num is out of range")?;
         let mut conn = self.pool.get().await?;
-        let world_stmt = conn.prepare_cache(WORLD_SQL, WORLD_SQL_TYPES).await?;
-        let update_stmt = conn.prepare_cache(update, &[]).await?;
+        let world_stmt = WORLD_STMT.execute_mut(&mut conn).await?;
+        let update_stmt = Statement::named(update, &[]).execute_mut(&mut conn).await?;
 
         let mut params = Vec::with_capacity(len);
 
@@ -97,10 +98,10 @@ impl Client {
                 let w_id = rng.gen_id();
                 let r_id = rng.gen_id();
                 params.push([w_id, r_id]);
-                pipe.query(world_stmt.bind([w_id]))
+                world_stmt.bind([w_id]).query_mut(&mut pipe)
             })?;
-            pipe.query(update_stmt.bind(sort_update_params(&params)))?;
-            conn.consume().pipeline(pipe)?
+            update_stmt.bind(sort_update_params(&params)).query_mut(&mut pipe)?;
+            pipe.query(&conn.consume())?
         };
 
         let mut worlds = Vec::with_capacity(len);
@@ -122,8 +123,8 @@ impl Client {
         items.push(Fortune::new(0, "Additional fortune added at request time."));
 
         let mut conn = self.pool.get().await?;
-        let stmt = conn.prepare_cache(FORTUNE_SQL, FORTUNE_SQL_TYPES).await?;
-        let mut res = conn.consume().query(&stmt)?;
+        let stmt = FORTUNE_STMT.execute_mut(&mut conn).await?;
+        let mut res = stmt.query(&conn.consume()).await?;
 
         while let Some(row) = res.try_next().await? {
             items.push(Fortune::new(row.get(0), row.get::<String>(1)));