feat: update

Author: eastspire

frameworks/Rust/hyperlane/src/db.rs

@@ -119,9 +119,13 @@ pub async fn get_update_data(
     let db_pool: &DbPoolConnection = get_db_connection();
     let mut query_res_list: Vec<QueryRow> = Vec::with_capacity(limit as usize);
     let rows: Vec<QueryRow> = get_some_row_id(limit, db_pool).await;
-    let mut sql: String = format!("UPDATE {} SET randomNumber = CASE id ", TABLE_NAME_WORLD);
+    let mut sql: String = String::with_capacity(rows.len() * 32);
+    sql.push_str(&format!(
+        "UPDATE {} SET randomNumber = CASE id ",
+        TABLE_NAME_WORLD
+    ));
     let mut id_list: Vec<i32> = Vec::with_capacity(rows.len());
-    let mut value_list: Vec<String> = Vec::with_capacity(rows.len() * 2);
+    let mut value_list: Vec<String> = Vec::with_capacity(rows.len());
     let mut random_numbers: Vec<i32> = Vec::with_capacity(rows.len());
     for (i, row) in rows.iter().enumerate() {
         let new_random_number: i32 = get_random_id() as i32;
@@ -131,10 +135,8 @@ pub async fn get_update_data(
         query_res_list.push(QueryRow::new(row.id, new_random_number));
     }
     sql.push_str(&value_list.join(" "));
-    let id_params: String = id_list
-        .iter()
-        .enumerate()
-        .map(|(i, _)| format!("${}", (rows.len() * 2 + 1) + i))
+    let id_params: String = (0..rows.len())
+        .map(|i| format!("${}", (rows.len() * 2 + 1) + i))
         .collect::<Vec<_>>()
         .join(",");
     sql.push_str(&format!(
@@ -174,7 +176,7 @@ pub async fn query_world_row(db_pool: &DbPoolConnection, id: Queries) -> QueryRo
 pub async fn update_world_rows(limit: Queries) -> Vec<QueryRow> {
     let db_pool: &DbPoolConnection = get_db_connection();
     let (sql, data, id_list, random_numbers) = get_update_data(limit).await;
-    let mut query_builder: query::Query<'_, Postgres, postgres::PgArguments> = query(&sql);
+    let mut query_builder = query(&sql);
     for (id, random_number) in id_list.iter().zip(random_numbers.iter()) {
         query_builder = query_builder.bind(id).bind(random_number);
     }
@@ -194,18 +196,18 @@ pub async fn all_world_row() -> Vec<PgRow> {
 
 pub async fn get_some_row_id(limit: Queries, db_pool: &DbPoolConnection) -> Vec<QueryRow> {
     let semaphore: Arc<Semaphore> = Arc::new(Semaphore::new(32));
-    let mut tasks: Vec<JoinHandle<QueryRow>> = Vec::with_capacity(limit as usize);
-    for _ in 0..limit {
-        let _ = semaphore.clone().acquire_owned().await.map(|permit| {
-            let db_pool: DbPoolConnection = db_pool.clone();
-            tasks.push(spawn(async move {
+    let tasks: Vec<_> = (0..limit)
+        .map(|_| {
+            let semaphore: Arc<Semaphore> = semaphore.clone();
+            let db_pool: Pool<Postgres> = db_pool.clone();
+            spawn(async move {
+                let _permit: Result<OwnedSemaphorePermit, AcquireError> =
+                    semaphore.acquire_owned().await;
                 let id: i32 = get_random_id();
-                let res: QueryRow = query_world_row(&db_pool, id).await;
-                drop(permit);
-                res
-            }));
-        });
-    }
+                query_world_row(&db_pool, id).await
+            })
+        })
+        .collect();
     join_all(tasks)
         .await
         .into_iter()

frameworks/Rust/hyperlane/src/main.rs

@@ -17,13 +17,15 @@ pub(crate) use hyperlane::{
     once_cell::sync::Lazy,
     serde::*,
     serde_json::{Value, json},
-    tokio::{spawn, sync::Semaphore, task::JoinHandle},
+    tokio::{
+        spawn,
+        sync::{AcquireError, OwnedSemaphorePermit, Semaphore},
+        task::JoinHandle,
+    },
     *,
 };
 pub(crate) use lazy::*;
 pub(crate) use rand::{Rng, SeedableRng, rng, rngs::SmallRng};
-pub(crate) use request_middleware::*;
-pub(crate) use route::*;
 pub(crate) use server::*;
 pub(crate) use sqlx::{
     postgres::{PgPoolOptions, PgRow},

frameworks/Rust/hyperlane/src/request_middleware.rs

@@ -9,12 +9,11 @@ pub async fn request(ctx: Context) {
         .await;
     #[cfg(feature = "plaintext")]
     {
-        set_response_header(CONTENT_TYPE, TEXT_PLAIN).await;
+        ctx.set_response_header(CONTENT_TYPE, TEXT_PLAIN).await;
     }
     #[cfg(feature = "fortunes")]
     {
-        ctx = ctx
-            .set_response_header(CONTENT_TYPE, content_type_charset(TEXT_HTML, UTF8))
+        ctx.set_response_header(CONTENT_TYPE, content_type_charset(TEXT_HTML, UTF8))
             .await;
     }
     #[cfg(any(
@@ -25,8 +24,7 @@ pub async fn request(ctx: Context) {
         feature = "cached_query"
     ))]
     {
-        ctx = ctx
-            .set_response_header(CONTENT_TYPE, APPLICATION_JSON)
+        ctx.set_response_header(CONTENT_TYPE, APPLICATION_JSON)
             .await;
     }
 }

frameworks/Rust/hyperlane/src/route.rs

@@ -21,7 +21,7 @@ pub async fn db(ctx: Context) {
         .await;
 }
 
-pub async fn queries(ctx: Context) {
+pub async fn query(ctx: Context) {
     let queries: Queries = ctx
         .get_request_query("q")
         .await
@@ -55,7 +55,7 @@ pub async fn fortunes(ctx: Context) {
     let _ = ctx.send_response(200, res).await;
 }
 
-pub async fn updates(ctx: Context) {
+pub async fn update(ctx: Context) {
     let queries: Queries = ctx
         .get_request_query("q")
         .await
@@ -69,7 +69,7 @@ pub async fn updates(ctx: Context) {
         .await;
 }
 
-pub async fn cached_queries(ctx: Context) {
+pub async fn cached_query(ctx: Context) {
     let count: Queries = ctx
         .get_request_query("c")
         .await

frameworks/Rust/hyperlane/src/server.rs

@@ -23,21 +23,21 @@ async fn init_server() {
     server.disable_inner_print().await;
     server.http_line_buffer_size(256).await;
     server.websocket_buffer_size(256).await;
-    server.request_middleware(request).await;
+    server.request_middleware(request_middleware::request).await;
     #[cfg(feature = "plaintext")]
-    server.route("/plaintext", plaintext).await;
+    server.route("/plaintext", route::plaintext).await;
     #[cfg(feature = "json")]
-    server.route("/json", json).await;
+    server.route("/json", route::json).await;
     #[cfg(feature = "cached_query")]
-    server.route("/cached-quer", cached_queries).await;
+    server.route("/cached-quer", route::cached_query).await;
     #[cfg(feature = "db")]
-    server.route("/db", db).await;
+    server.route("/db", route::db).await;
     #[cfg(feature = "query")]
-    server.route("/query", queries).await;
+    server.route("/query", route::query).await;
     #[cfg(feature = "fortunes")]
-    server.route("/fortunes", fortunes).await;
+    server.route("/fortunes", route::fortunes).await;
     #[cfg(feature = "update")]
-    server.route("/upda", updates).await;
+    server.route("/upda", route::update).await;
     server.listen().await.unwrap();
 }