autoformatting

macros/src/lib.rs

@@ -4,8 +4,6 @@ use syn::{parse_macro_input, Data, DeriveInput, Fields};
 
 // TODO: wrap functions in a trait
 
-// TODO: add sync function (set fields of self by querying db)
-
 // TODO: doc comments
 
 #[proc_macro_derive(Table)]
@@ -126,7 +124,7 @@ pub fn derive_table(input: TokenStream) -> TokenStream {
     );
 
     let update_fn = quote! {
-        pub fn update(&mut self, conn: &rusqlite::Connection) -> rusqlite::Result<bool>
+        pub fn update(&self, conn: &rusqlite::Connection) -> rusqlite::Result<bool>
             where #(#to_sql_trait_bounds),*
         {
             if self.id.is_none() {
@@ -138,6 +136,22 @@ pub fn derive_table(input: TokenStream) -> TokenStream {
     };
 
 
+    let sync_fn = quote! {
+        pub fn sync(&mut self, conn: &rusqlite::Connection) -> rusqlite::Result<bool>
+            where #(#from_sql_trait_bounds),*
+        {
+            if self.id.is_none() {
+                return Ok(false);
+            }
+            match #struct_name::get_by_id(conn, self.id.unwrap())? {
+                Some(person) => *self = person,
+                _ => return Ok(false),
+            };
+            Ok(true)
+        }
+    };
+
+
     let get_by_id_fn = quote! {
         pub fn get_by_id(conn: &rusqlite::Connection, id: i64) -> rusqlite::Result<Option<Self>>
         where
@@ -197,6 +211,7 @@ pub fn derive_table(input: TokenStream) -> TokenStream {
             #insert_fn
             #upsert_fn
             #update_fn
+            #sync_fn
             #get_by_id_fn
             #delete_fn
             #delete_by_id_fn

src/test/macros.rs

@@ -16,7 +16,7 @@ fn test_table_derive_macro() {
     #[derive(Clone, Default, Debug, PartialEq, Eq)]
     struct Point {
         x: i16,
-        y: i16
+        y: i16,
     }
 
     impl rusqlite::types::ToSql for Point {
@@ -26,11 +26,14 @@ fn test_table_derive_macro() {
     }
 
     impl rusqlite::types::FromSql for Point {
-        fn column_result(value: rusqlite::types::ValueRef<'_>) -> rusqlite::types::FromSqlResult<Self> {
+        fn column_result(
+            value: rusqlite::types::ValueRef<'_>,
+        ) -> rusqlite::types::FromSqlResult<Self> {
             match value {
                 rusqlite::types::ValueRef::Text(v) => {
                     let values = String::from_utf8(v.into()).unwrap();
-                    let values = values.split_ascii_whitespace()
+                    let values = values
+                        .split_ascii_whitespace()
                         .map(|w| w.parse::<i16>().unwrap())
                         .collect::<Vec<_>>();
 
@@ -38,8 +41,11 @@ fn test_table_derive_macro() {
                         x: values[0],
                         y: values[1],
                     })
-                },
-                t => panic!("Wrong SQL type recieved for query of Point. Should be Text but is {:?}", t),
+                }
+                t => panic!(
+                    "Wrong SQL type recieved for query of Point. Should be Text but is {:?}",
+                    t
+                ),
             }
         }
     }
@@ -56,41 +62,83 @@ fn test_table_derive_macro() {
     Person::create_table(&conn).unwrap();
 
     larry.insert(&conn).unwrap();
-    let larry_id = larry.id.expect("After (mutable) insertion, id should not be None");
+    let larry_id = larry
+        .id
+        .expect("After (mutable) insertion, id should not be None");
 
     larry.age += 1;
     let updated_something = larry.update(&conn).expect("Updating should work");
     assert!(updated_something, "Should have updated a row");
 
     let larry_copy = Person::get_by_id(&conn, larry_id).expect("Querying a row should work");
-    assert_eq!(larry_copy, Some(larry.clone()), "Retrieving inserted row should give an identical row");
+    assert_eq!(
+        larry_copy,
+        Some(larry.clone()),
+        "Retrieving inserted row should give an identical row"
+    );
 
     let deleted_something = larry.delete(&conn).expect("Deletion should work");
     // also works: `Person::delete_by_id(&conn, larry_id).unwrap();`
     assert!(deleted_something, "Should have deleted something");
 
-    let deleted_larry = Person::get_by_id(&conn, larry_id).expect("Querying a deleted row should return Ok(None), not Err(_)");
-    assert_eq!(deleted_larry, None, "Received row that should have been deleted");
+    let deleted_larry = Person::get_by_id(&conn, larry_id)
+        .expect("Querying a deleted row should return Ok(None), not Err(_)");
+    assert_eq!(
+        deleted_larry, None,
+        "Received row that should have been deleted"
+    );
 
     let id = larry.upsert(&conn).expect("Upsertion (insert) should work");
-    let larry_id = larry.id.expect("After (mutable) upsertion, id should not be None");
+    let larry_id = larry
+        .id
+        .expect("After (mutable) upsertion, id should not be None");
 
     let larry_copy = Person::get_by_id(&conn, larry_id).expect("Querying a row should work");
     assert_eq!(id, larry_id, "Upsert should return correct id");
-    assert_eq!(larry_copy, Some(larry.clone()), "Retrieving upserted row should give an identical row");
+    assert_eq!(
+        larry_copy,
+        Some(larry.clone()),
+        "Retrieving upserted row should give an identical row"
+    );
 
     larry.age += 1;
     let id = larry.upsert(&conn).expect("Upsertion (update) should work");
-    let larry_id = larry.id.expect("After (mutable) upsertion, id should not be None");
+    let larry_id = larry
+        .id
+        .expect("After (mutable) upsertion, id should not be None");
     assert_eq!(id, larry_id, "Upsert should return correct id");
 
     let larry_copy = Person::get_by_id(&conn, larry_id).expect("Querying a row should work");
-    assert_eq!(larry_copy, Some(larry.clone()), "Retrieving upserted row should give an identical row");
+    assert_eq!(
+        larry_copy,
+        Some(larry.clone()),
+        "Retrieving upserted row should give an identical row"
+    );
+
+    conn.execute("UPDATE Person SET (age) = (27) WHERE id = ?1", [larry_id])
+        .expect("Explicit Sqlite statement (not a library test) failed");
+
+    let found = larry
+        .sync(&conn)
+        .expect("Syncing struct to existing row should succeed");
+    assert!(found, "Row should have been found");
+    assert_eq!(
+        larry.age, 27,
+        "Syncing struct to edited table row should work"
+    );
 
     Person::drop_table(&conn).expect("Dropping table should work");
     Person::drop_table(&conn).expect_err("Dropping previously dropped table should err");
-}
 
+    let exists: bool = conn
+        .query_row(
+            "SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE type='table' AND name='Person');",
+            [],
+            |row| row.get(0),
+        )
+        .expect("Explicit Sqlite statement (not a library test) failed");
+    assert!(!exists, "Deleted table should not exist anymore but does");
+}
 
 // TODO: implement compile-error test(s) -- perhaps with `trybuild`?
 //
@@ -105,4 +153,3 @@ fn test_table_derive_macro() {
 //         data: i64, // missing `id: Option<i64>`
 //     }
 // }
-