Address issues

Author: nociza

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "colink"
-version = "0.3.7"
+version = "0.3.8"
 edition = "2021"
 description = "CoLink Rust SDK"
 license = "MIT"
@@ -23,7 +23,7 @@ lapin = "2.1"
 prost = "0.10"
 rand = { version = "0.8", features = ["std_rng"] }
 rcgen = { version = "0.10", optional = true }
-rdbc2 = { version = "0.2.0", optional = true }
+rdbc2 = { version = "0.2.2", optional = true }
 redis = { version = "0.22", features = ["tokio-comp"] }
 reqwest = { version = "0.11", default-features = false, features = ["rustls-tls-native-roots"], optional = true }
 secp256k1 = { version = "0.25", features = ["rand-std"] }

src/extensions/instant_server.rs

@@ -81,7 +81,7 @@ impl InstantServer {
             .join(instant_server_id.clone());
         std::fs::create_dir_all(&working_dir).unwrap();
         let mut user_init_config_file =
-            std::fs::File::create(&Path::new(&working_dir).join("user_init_config.toml")).unwrap();
+            std::fs::File::create(Path::new(&working_dir).join("user_init_config.toml")).unwrap();
         user_init_config_file
             .write_all(user_init_config.as_bytes())
             .unwrap();

src/extensions/storage_macro/dbc.rs

@@ -5,32 +5,27 @@ type Error = Box<dyn std::error::Error + Send + Sync + 'static>;
 
 impl crate::application::CoLink {
     #[async_recursion]
-    async fn _search_and_generate_query_string(
+    async fn _search_and_generate_query(
         &self,
         string_before_dbc: &str,
         string_after_dbc: &str,
-    ) -> Result<String, Error> {
+    ) -> Result<(String, Vec<String>), Error> {
         let split_key_path: Vec<&str> = string_after_dbc.split(':').collect();
-        for i in 0..split_key_path.len() {
-            let current_key_path = format!(
-                "{}:{}",
-                string_before_dbc,
-                split_key_path[0..i + 1].join(":")
-            );
+        for i in (0..split_key_path.len()).rev() {
+            let current_key_path =
+                format!("{}:{}", string_before_dbc, split_key_path[0..=i].join(":"));
             let payload = self.read_entry(current_key_path.as_str()).await;
-            if payload.is_ok() {
-                let query_string_raw = String::from_utf8(payload.unwrap())?;
-                let count = query_string_raw.matches('?').count();
+            if let Ok(payload) = payload {
+                let query_string = String::from_utf8(payload)?;
+                let count = query_string.matches('?').count();
                 if count != split_key_path.len() - (i + 1) {
                     return Err("Number of parameters does not match specified query string")?;
                 }
-                let mut query_string = query_string_raw;
-                for j in 0..count {
-                    query_string = query_string.replacen('?', split_key_path[i + j + 1], 1);
-                }
-                return Ok(query_string);
-            } else {
-                continue;
+                let params = split_key_path[(i + 1)..]
+                    .iter()
+                    .map(|x| x.to_string())
+                    .collect::<Vec<String>>();
+                return Ok((query_string, params));
             }
         }
         Err("no query string found.")?
@@ -45,12 +40,13 @@ impl crate::application::CoLink {
         let url_key = format!("{}:url", string_before_dbc);
         let url = self.read_entry(url_key.as_str()).await?;
         let url_string = String::from_utf8(url)?;
-        let query_string = self
-            ._search_and_generate_query_string(string_before_dbc, string_after_dbc)
+        let (query_string, params) = self
+            ._search_and_generate_query(string_before_dbc, string_after_dbc)
             .await?;
+        let params: Vec<&str> = params.iter().map(AsRef::as_ref).collect();
         let mut database = rdbc2::dbc::Database::new(url_string.as_str())?;
-        let result = database.execute_query(query_string.as_str())?;
-        let seraliased_result = serde_json::to_vec(&result)?;
-        Ok(seraliased_result)
+        let result = database.execute_query_with_params(query_string.as_str(), &params)?;
+        let seralized_result = serde_json::to_vec(&result)?;
+        Ok(seralized_result)
     }
 }

tests/test_storage_macro_dbc.rs

@@ -60,17 +60,40 @@ async fn test_storage_macro_dbc_mysql(
     let query_result = cl
         .read_entry("storage_macro_test:db:$dbc:query_users:'Alice':'20'")
         .await?;
-    cl.read_entry("storage_macro_test:db:$dbc:cleanup").await?;
 
     let stringified = String::from_utf8(query_result.clone())?;
     println!("{}", stringified);
     assert_eq!(
         stringified,
-        r#"{"rows":[{"values":[{"Bytes":[65,108,105,99,101]},{"Int":20}],"columns":[{"name":"name","column_type":"VARCHAR"},{"name":"age","column_type":"INT"}]}],"affected_rows":0}"#
+        r#"{"rows":[{"values":[{"Bytes":"QWxpY2U"},{"Int":20}],"columns":[{"name":"name","column_type":"VARCHAR"},{"name":"age","column_type":"INT"}]}],"affected_row_count":0}"#
     );
 
     let deserialized: rdbc2::dbc::QueryResult = serde_json::from_slice(&query_result)?;
     assert_eq!(deserialized.rows.len(), 1);
 
+    // Test query string parsing order
+    cl.create_entry(
+        "storage_macro_test:db:query_users2",
+        b"SELECT * FROM users WHERE name = ? AND age = ?" as &[u8],
+    )
+    .await?;
+
+    cl.create_entry(
+        "storage_macro_test:db:query_users2:additional",
+        b"SELECT * FROM users WHERE name = ?" as &[u8],
+    )
+    .await?;
+
+    let result = cl
+        .read_entry("storage_macro_test:db:$dbc:query_users2:additional:'Alice'")
+        .await?;
+
+    assert_eq!(
+        String::from_utf8(result)?,
+        r#"{"rows":[{"values":[{"Bytes":"QWxpY2U"},{"Int":20}],"columns":[{"name":"name","column_type":"VARCHAR"},{"name":"age","column_type":"INT"}]}],"affected_row_count":0}"#
+    );
+
+    cl.read_entry("storage_macro_test:db:$dbc:cleanup").await?;
+
     Ok(())
 }