substantial sqlite tests and add affected_rows

nociza · nociza · commit c20970af5527 · 2023-04-05T00:09:10.000-07:00
diff --git a/src/dbc.rs b/src/dbc.rs
@@ -132,6 +132,7 @@ impl Row {
 #[derive(Serialize, Deserialize, Debug)]
 pub struct QueryResult {
     pub rows: Vec<Row>,
+    pub affected_rows: usize,
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
diff --git a/src/dbc/mysql.rs b/src/dbc/mysql.rs
@@ -1,7 +1,9 @@
 use std::sync::Arc;
+
 use mysql;
 use mysql::prelude::Queryable;
 use mysql_common::constants::ColumnType;
+
 use crate::dbc;
 
 pub(crate) struct MySQLConnection {
@@ -19,36 +21,40 @@ impl MySQLConnection {
 impl dbc::Connection for MySQLConnection {
     fn execute(&mut self, query: &str) -> Result<dbc::QueryResult, dbc::Error> {
         let result = self.connection.query_iter(query)?;
-        let columns = result.columns().as_ref().iter().map(
-            |column| {
-                dbc::Column {
-                    name: column.name_str().to_string(),
-                    column_type: column.column_type().into(),
-                }
-            }
-        ).collect::<Vec<dbc::Column>>();
+        let affected_rows = result.affected_rows() as usize;
+        let columns = result
+            .columns()
+            .as_ref()
+            .iter()
+            .map(|column| dbc::Column {
+                name: column.name_str().to_string(),
+                column_type: column.column_type().into(),
+            })
+            .collect::<Vec<dbc::Column>>();
         let columns = Arc::from(columns);
 
-
         let mut rows: Vec<dbc::Row> = Vec::new();
         for row in result {
             let row = row?;
-            let values: Vec<dbc::Value> = row.unwrap_raw().iter().map(
-                |value| {
+            let values: Vec<dbc::Value> = row
+                .unwrap_raw()
+                .iter()
+                .map(|value| {
                     if value.is_none() {
                         dbc::Value::NULL
                     } else {
                         value.as_ref().unwrap().into()
                     }
-                }
-            ).collect();
+                })
+                .collect();
             rows.push(dbc::Row {
                 values,
                 columns: Arc::clone(&columns),
             });
         }
-        Ok(dbc::QueryResult{
+        Ok(dbc::QueryResult {
             rows,
+            affected_rows,
         })
     }
 }
@@ -62,8 +68,12 @@ impl From<&mysql::Value> for dbc::Value {
             mysql::Value::UInt(uint) => dbc::Value::UInt(*uint),
             mysql::Value::Float(float) => dbc::Value::Float(*float),
             mysql::Value::Double(double) => dbc::Value::Double(*double),
-            mysql::Value::Date(year, month, day, hour, minute, second, microsecond) => dbc::Value::Date(*year, *month, *day, *hour, *minute, *second, *microsecond),
-            mysql::Value::Time(negative, days, hours, minutes, seconds, microseconds) => dbc::Value::Time(*negative, *days, *hours, *minutes, *seconds, *microseconds),
+            mysql::Value::Date(year, month, day, hour, minute, second, microsecond) => {
+                dbc::Value::Date(*year, *month, *day, *hour, *minute, *second, *microsecond)
+            }
+            mysql::Value::Time(negative, days, hours, minutes, seconds, microseconds) => {
+                dbc::Value::Time(*negative, *days, *hours, *minutes, *seconds, *microseconds)
+            }
         }
     }
 }
@@ -107,4 +117,4 @@ impl From<ColumnType> for dbc::ColumnType {
             }
         }
     }
-}
+}
diff --git a/src/dbc/sqlite.rs b/src/dbc/sqlite.rs
@@ -16,26 +16,34 @@ impl SQLiteConnection {
         } else {
             connection = rusqlite::Connection::open(url)?;
         }
-        Ok(Box::new(SQLiteConnection {
-            connection,
-        }) as Box<dyn dbc::Connection>)
+        Ok(Box::new(SQLiteConnection { connection }) as Box<dyn dbc::Connection>)
     }
 }
 
 impl dbc::Connection for SQLiteConnection {
     fn execute(&mut self, query: &str) -> Result<dbc::QueryResult, dbc::Error> {
         let mut statement = self.connection.prepare(query)?;
-        let columns = statement.column_names().iter().map(
-            |column| {
+        let columns = statement
+            .column_names()
+            .iter()
+            .map(|column| {
                 dbc::Column {
                     name: column.to_string(),
                     column_type: dbc::ColumnType::STRING, // TODO: get column type
                 }
-            }
-        ).collect::<Vec<dbc::Column>>();
+            })
+            .collect::<Vec<dbc::Column>>();
         let columns = Arc::from(columns);
         let num_columns = statement.column_count();
 
+        if !query.starts_with("SELECT") {
+            let affected_rows = statement.execute([])?;
+            return Ok(dbc::QueryResult {
+                rows: Vec::new(),
+                affected_rows,
+            });
+        }
+
         let mut rows: Vec<dbc::Row> = Vec::new();
         let mut result = statement.query([])?;
         while let Some(row) = result.next()? {
@@ -50,8 +58,10 @@ impl dbc::Connection for SQLiteConnection {
                 columns: Arc::clone(&columns),
             });
         }
+        let affected_rows = rows.len();
         Ok(dbc::QueryResult {
             rows,
+            affected_rows,
         })
     }
 }
diff --git a/tests/mysql_test.rs b/tests/mysql_test.rs
@@ -128,7 +128,7 @@ async fn test_mysql_query_with_params_and_serialize() -> Result<(), Error> {
     // Select all rows from test_table
     let select_query = "SELECT * FROM test_table WHERE id = ?";
     let result = database.execute_query_with_params_and_serialize(select_query, &["1"])?;
-    let expected_result = r#"{"rows":[{"values":[{"Bytes":[49]},{"Bytes":[117,112,100,97,116,101,100]}],"columns":[{"name":"id","column_type":"LONG"},{"name":"name","column_type":"STRING"}]}]}"#;
+    let expected_result = r#"{"rows":[{"values":[{"Bytes":[49]},{"Bytes":[117,112,100,97,116,101,100]}],"columns":[{"name":"id","column_type":"LONG"},{"name":"name","column_type":"STRING"}]}],"affected_rows":0}"#;
     assert_eq!(result, expected_result);
 
     // deserialize the result and verify the data
diff --git a/tests/sqlite_test.rs b/tests/sqlite_test.rs
@@ -5,29 +5,87 @@ type Error = Box<dyn std::error::Error + Send + Sync + 'static>;
 #[tokio::test]
 async fn test_sqlite_simple_query() -> Result<(), Error> {
     let mut database = dbc::Database::new("sqlite://:memory:")?;
-    let query = "SELECT 1";
-    let result = database.execute_query(query)?;
-    assert_eq!(result.rows.len(), 1);
 
-    Ok(())
-}
+    // Create a test table with two rows
+    let create_table_query = "CREATE TABLE test_table (id INTEGER PRIMARY KEY, name TEXT NOT NULL)";
+    database.execute_query(create_table_query)?;
+    let insert_query = "INSERT INTO test_table (name) VALUES ('test1'), ('test2')";
+    database.execute_query(insert_query)?;
 
-#[tokio::test]
-async fn test_sqlite_query_with_params() -> Result<(), Error> {
-    let mut database = dbc::Database::new("sqlite://:memory:")?;
-    let query = "SELECT ? + ?";
-    let result = database.execute_query_with_params(query, &["1", "2"])?;
+    // Select all rows from test_table
+    let select_query = "SELECT * FROM test_table";
+    let result = database.execute_query(select_query)?;
+    assert_eq!(result.rows.len(), 2);
+
+    // Verify the data returned by the query
+    let first_row = &result.rows[0];
+    let second_row = &result.rows[1];
+    assert_eq!(
+        first_row.get_value_by_name("name"),
+        Some(&dbc::Value::Bytes("test1".to_owned().into_bytes()))
+    );
+    assert_eq!(
+        second_row.get_value_by_name("name"),
+        Some(&dbc::Value::Bytes("test2".to_owned().into_bytes()))
+    );
+
+    // Update the name of the first row to "updated"
+    let update_query = "UPDATE test_table SET name = ? WHERE id = ?";
+    let result = database.execute_query_with_params(update_query, &["updated", "1"])?;
+    assert_eq!(result.affected_rows, 1);
+
+    // Select the first row from test_table where the name is "updated"
+    let select_query = "SELECT * FROM test_table WHERE name = ?";
+    let result = database.execute_query_with_params(select_query, &["updated"])?;
     assert_eq!(result.rows.len(), 1);
 
+    // Verify the data returned by the query
+    let first_row = &result.rows[0];
+    assert_eq!(
+        first_row.get_value_by_name("name"),
+        Some(&dbc::Value::Bytes("updated".to_owned().into_bytes()))
+    );
+
     Ok(())
 }
 
 #[tokio::test]
 async fn test_sqlite_query_with_params_and_serialize() -> Result<(), Error> {
     let mut database = dbc::Database::new("sqlite://:memory:")?;
-    let query = "SELECT ? + ?";
-    let result = database.execute_query_with_params_and_serialize(query, &["1", "2"])?;
-    assert_eq!(result, r#"{"rows":[{"values":[{"Int":2}],"columns":[{"name":"1 + 1","column_type":"STRING"}]}]}"#); // currently all columns are STRING
+
+    // Create a test table with two rows
+    let create_table_query = "CREATE TABLE test_table (id INTEGER PRIMARY KEY, name TEXT NOT NULL)";
+    database.execute_query(create_table_query)?;
+    let insert_query = "INSERT INTO test_table (name) VALUES ('test1'), ('test2')";
+    database.execute_query(insert_query)?;
+
+    // Select all rows from test_table where the name is "test1"
+    let select_query = "SELECT * FROM test_table WHERE name = ?";
+    let result = database.execute_query_with_params_and_serialize(select_query, &["test1"])?;
+    assert_eq!(
+        result,
+        r#"{"rows":[{"values":[{"Int":1},{"Bytes":[116,101,115,116,49]}],"columns":[{"name":"id","column_type":"STRING"},{"name":"name","column_type":"STRING"}]}],"affected_rows":1}"#
+    ); // Note: The column type is STRING because the column type is not known in the current implementation
+
+    // Update the name of the first row to "updated"
+    let update_query = "UPDATE test_table SET name = ? WHERE id = ?";
+    database.execute_query_with_params_and_serialize(update_query, &["updated", "1"])?;
+
+    // Select the first row from test_table where the id is 1
+    let select_query = "SELECT * FROM test_table WHERE id = ?";
+    let result = database.execute_query_with_params_and_serialize(select_query, &["1"])?;
+    assert_eq!(
+        result,
+        r#"{"rows":[{"values":[{"Int":1},{"Bytes":[117,112,100,97,116,101,100]}],"columns":[{"name":"id","column_type":"STRING"},{"name":"name","column_type":"STRING"}]}],"affected_rows":1}"#
+    );
+
+    // Deserialize the result and verify the data
+    let result: dbc::QueryResult = serde_json::from_str(&result)?;
+    let first_row = &result.rows[0];
+    assert_eq!(
+        first_row.get_value_by_name("name"),
+        Some(&dbc::Value::Bytes("updated".to_owned().into_bytes()))
+    );
 
     Ok(())
-}
+}

Original file line number	Diff line number	Diff line change
`@@ -132,6 +132,7 @@ impl Row {`
`132`	`132`	`#[derive(Serialize, Deserialize, Debug)]`
`133`	`133`	`pub struct QueryResult {`
`134`	`134`	`pub rows: Vec<Row>,`
	`135`	`+ pub affected_rows: usize,`
`135`	`136`	`}`
`136`	`137`
`137`	`138`	`#[derive(Serialize, Deserialize, Clone, Debug)]`