feat: db

Author: eastspire

frameworks/Rust/hyperlane/src/db.rs

@@ -17,7 +17,7 @@ pub async fn get_db_connection() -> DbPoolConnection {
 #[cfg(feature = "dev")]
 pub async fn create_batabase() {
     let db_pool: DbPoolConnection = get_db_connection().await;
-    let _ = sqlx::query(&format!("CREATE DATABASE {};", DATABASE_NAME))
+    let _ = query(&format!("CREATE DATABASE {};", DATABASE_NAME))
         .execute(&db_pool)
         .await;
 }
@@ -26,15 +26,15 @@ pub async fn create_batabase() {
 #[cfg(feature = "dev")]
 pub async fn create_table() {
     let db_pool: DbPoolConnection = get_db_connection().await;
-    let _ = sqlx::query(&format!(
+    let _ = query(&format!(
         "CREATE TABLE IF NOT EXISTS {} (
             id SERIAL PRIMARY KEY, randomNumber INT NOT NULL
         );",
         TABLE_NAME_WORLD
     ))
     .execute(&db_pool)
     .await;
-    let _ = sqlx::query(&format!(
+    let _ = query(&format!(
         "CREATE TABLE IF NOT EXISTS {} (
             id SERIAL PRIMARY KEY, message VARCHAR NOT NULL
         );",
@@ -45,10 +45,9 @@ pub async fn create_table() {
 }
 
 #[inline]
-#[cfg(feature = "dev")]
 pub async fn insert_records() {
     let db_pool: DbPoolConnection = get_db_connection().await;
-    let row: PgRow = sqlx::query(&format!("SELECT COUNT(*) FROM {}", TABLE_NAME_WORLD))
+    let row: PgRow = query(&format!("SELECT COUNT(*) FROM {}", TABLE_NAME_WORLD))
         .fetch_one(&db_pool)
         .await
         .unwrap();
@@ -58,29 +57,29 @@ pub async fn insert_records() {
         return;
     }
     let missing_count: i64 = limit - count;
-    let mut rng: rand::prelude::ThreadRng = rand::rng();
+    let mut rng: ThreadRng = rng();
     let mut values: Vec<String> = Vec::new();
     for _ in 0..missing_count {
         let random_number: i32 = rng.random_range(1..=RANDOM_MAX);
         values.push(format!("(DEFAULT, {})", random_number));
     }
-    let query: String = format!(
+    let sql: String = format!(
         "INSERT INTO {} (id, randomNumber) VALUES {}",
         TABLE_NAME_WORLD,
         values.join(",")
     );
-    let _ = sqlx::query(&query).execute(&db_pool).await;
+    let _ = query(&sql).execute(&db_pool).await;
     let mut values: Vec<String> = Vec::new();
     for _ in 0..missing_count {
         let random_number: String = rng.random_range(1..=RANDOM_MAX).to_string();
         values.push(format!("(DEFAULT, {})", random_number));
     }
-    let query: String = format!(
+    let sql: String = format!(
         "INSERT INTO {} (id, message) VALUES {}",
         TABLE_NAME_FORTUNE,
         values.join(",")
     );
-    let _ = sqlx::query(&query).execute(&db_pool).await;
+    let _ = query(&sql).execute(&db_pool).await;
 }
 
 #[inline]
@@ -91,7 +90,7 @@ pub async fn init_cache() {
         "SELECT id, randomNumber FROM {} LIMIT {}",
         TABLE_NAME_WORLD, RANDOM_MAX
     );
-    if let Ok(rows) = sqlx::query(&sql).fetch_all(&db_pool).await {
+    if let Ok(rows) = query(&sql).fetch_all(&db_pool).await {
         for row in rows {
             let id: i32 = row.get(KEY_ID);
             let random_number: i32 = row.get(KEY_RANDOM_NUMBER);
@@ -165,8 +164,8 @@ pub async fn init_db() {
     {
         create_batabase().await;
         create_table().await;
-        insert_records().await;
     }
+    insert_records().await;
     init_cache().await;
 }
 
@@ -177,7 +176,7 @@ pub async fn random_world_row(db_pool: &DbPoolConnection) -> QueryRow {
         "SELECT id, randomNumber FROM {} WHERE id = {}",
         TABLE_NAME_WORLD, random_id
     );
-    if let Ok(rows) = sqlx::query(&sql).fetch_one(db_pool).await {
+    if let Ok(rows) = query(&sql).fetch_one(db_pool).await {
         let random_number: i32 = rows.get(KEY_RANDOM_NUMBER);
         return QueryRow::new(random_id, random_number);
     }
@@ -189,7 +188,7 @@ pub async fn update_world_rows(limit: Queries) -> Vec<QueryRow> {
     let db_pool: DbPoolConnection = get_db_connection().await;
     let (sql, data) = get_update_data(limit).await;
     spawn(async move {
-        let _ = sqlx::query(&sql).execute(&db_pool).await;
+        let _ = query(&sql).execute(&db_pool).await;
     });
     data
 }
@@ -198,10 +197,7 @@ pub async fn update_world_rows(limit: Queries) -> Vec<QueryRow> {
 pub async fn all_world_row() -> Vec<PgRow> {
     let db_pool: DbPoolConnection = get_db_connection().await;
     let sql: String = format!("SELECT id, message FROM {}", TABLE_NAME_FORTUNE);
-    let res: Vec<PgRow> = sqlx::query(&sql)
-        .fetch_all(&db_pool)
-        .await
-        .unwrap_or_default();
+    let res: Vec<PgRow> = query(&sql).fetch_all(&db_pool).await.unwrap_or_default();
     return res;
 }
 

frameworks/Rust/hyperlane/src/main.rs

@@ -22,14 +22,14 @@ pub(crate) use hyperlane::{
 };
 pub(crate) use lazy::*;
 pub(crate) use r#type::*;
-pub(crate) use rand::Rng;
+pub(crate) use rand::{prelude::*, rng, Rng};
 pub(crate) use request_middleware::*;
 pub(crate) use response_middleware::*;
 pub(crate) use route::*;
 pub(crate) use server::*;
 pub(crate) use sqlx::{
     postgres::{PgPoolOptions, PgRow},
-    Pool, Postgres, Row,
+    *,
 };
 pub(crate) use std::{fmt, sync::Arc};
 pub(crate) use utils::*;