rename tables

src/data_provider/card_sets.rs

@@ -10,7 +10,7 @@ use rusqlite::Connection;
 
 pub fn load_sets(connection: &Connection) -> Result<Vec<DeckSettings>, NotificationData> {
     let mut stmt = connection
-        .prepare("SELECT id, name, forward, backward, filter FROM card_set")
+        .prepare("SELECT id, name, forward, backward, filter FROM decks")
         .expect("Failed to prepare state query");
     let iter = stmt
         .query_map([], |row| {
@@ -34,7 +34,7 @@ pub fn load_sets(connection: &Connection) -> Result<Vec<DeckSettings>, Notificat
 pub fn add_set(set: &mut DeckSettings, connection: &Connection) -> MaybeError {
     let index : u32 = connection
         .query_row(
-            "INSERT INTO card_set (name, forward, backward, filter) VALUES (?1, ?2, ?3, ?4) RETURNING id",
+            "INSERT INTO decks (name, forward, backward, filter) VALUES (?1, ?2, ?3, ?4) RETURNING id",
             (
                 &set.name,
                 &set.forward,
@@ -55,7 +55,7 @@ pub fn update_deck(set: &mut DeckSettings, connection: &Connection) -> MaybeErro
     } else {
         connection
             .execute(
-                "UPDATE card_set SET name = ?1, forward = ?2, backward = ?3, filter = ?4 WHERE id = ?5",
+                "UPDATE decks SET name = ?1, forward = ?2, backward = ?3, filter = ?4 WHERE id = ?5",
                 (
                     &set.name,
                     &set.forward,
@@ -74,7 +74,7 @@ pub fn delete_set(set: &DeckSettings, connection: &Connection) -> MaybeError {
         return Err(DbSaveError);
     }
     connection
-        .execute("DELETE FROM card_set WHERE id = ?1", (&set.id,))
+        .execute("DELETE FROM decks WHERE id = ?1", (&set.id,))
         .map_err(|_| DbSaveError)?;
     Ok(())
 }

src/data_provider/card_stats.rs

@@ -13,7 +13,7 @@ pub fn load_stats_of_deck(
     connection: &Connection,
 ) -> Result<Vec<CardStatistics>, NotificationData> {
     let mut stmt = connection
-        .prepare("SELECT id, word_id, score, last_opened, fsrs_opened, fsrs_memory, fsrs_open_day FROM card_stats WHERE set_id = ?1")
+        .prepare("SELECT id, word_id, score, last_opened, fsrs_opened, fsrs_memory, fsrs_open_day FROM states WHERE set_id = ?1")
         .expect("Failed to prepare state query");
     let iter = stmt
         .query_map((set.id,), |row| {
@@ -59,7 +59,7 @@ pub fn add_stat_list(stats: &mut [CardStatistics], connection: &mut Connection)
     {
         let mut stmt = tx
             .prepare(
-                "INSERT INTO card_stats (word_id, set_id, score, last_opened, fsrs_opened, fsrs_memory, fsrs_open_day) VALUES (?1, ?2, ?3, ?4)",
+                "INSERT INTO states (word_id, set_id, score, last_opened, fsrs_opened, fsrs_memory, fsrs_open_day) VALUES (?1, ?2, ?3, ?4)",
             )
             .expect("Failed to prepare state query");
 
@@ -98,7 +98,7 @@ pub fn update_stat_score(stat: &CardStatistics, connection: &Connection) -> Mayb
 
     connection
         .execute(
-            "UPDATE card_stats SET score = ?1, last_opened = ?2 WHERE id = ?3",
+            "UPDATE states SET score = ?1, last_opened = ?2 WHERE id = ?3",
             (&stat.score, &stat.last_open.timestamp(), &stat.id),
         )
         .map_err(|_| DbSaveError)?;
@@ -117,7 +117,7 @@ pub fn delete_stats(stat: &[CardStatistics], connection: &Connection) -> MaybeEr
         .join(", ");
     connection
         .execute(
-            format!("DELETE FROM card_stats WHERE id in ({ids})").as_str(),
+            format!("DELETE FROM states WHERE id in ({ids})").as_str(),
             (),
         )
         .map_err(|_| DbSaveError)?;

src/data_provider/sqlite.rs

@@ -30,15 +30,15 @@ fn make_settings(conn: &Connection) -> Result<(), rusqlite::Error> {
 }
 
 fn make_card_set(conn: &Connection) -> Result<(), rusqlite::Error> {
-    let query = include_str!("../../sql/card_set.sql");
+    let query = include_str!("../../sql/decks.sql");
     conn.execute(query, ())?;
     Ok(())
 }
 
 fn make_word_group(conn: &Connection) -> Result<(), rusqlite::Error> {
-    let query = include_str!("../../sql/word_group.sql");
+    let query = include_str!("../../sql/word_groups.sql");
     conn.execute(query, ())?;
-    conn.execute("insert into word_group (name) values (\"Слова\");", ())?;
+    conn.execute("insert into word_groups (name) values (\"Слова\");", ())?;
     Ok(())
 }
 fn make_words(conn: &Connection) -> Result<(), rusqlite::Error> {
@@ -47,7 +47,7 @@ fn make_words(conn: &Connection) -> Result<(), rusqlite::Error> {
     Ok(())
 }
 fn make_card_stats(conn: &Connection) -> Result<(), rusqlite::Error> {
-    let query = include_str!("../../sql/card_stats.sql");
+    let query = include_str!("../../sql/states.sql");
     conn.execute(query, ())?;
     Ok(())
 }

src/data_provider/words.rs

@@ -116,7 +116,7 @@ pub fn load_words(connection: &Connection) -> Result<Vec<WordData>, Notification
 
 pub fn load_word_groups(connection: &Connection) -> Result<Vec<WordGroup>, NotificationData> {
     let mut stmt = connection
-        .prepare("SELECT id, name FROM word_group")
+        .prepare("SELECT id, name FROM word_groups")
         .expect("Failed to prepare statement");
     let group_iter = stmt
         .query_map([], |row| {
@@ -138,7 +138,7 @@ pub fn load_word_groups(connection: &Connection) -> Result<Vec<WordGroup>, Notif
 pub fn add_group(group: &mut WordGroup, connection: &Connection) -> MaybeError {
     let index: u32 = connection
         .query_row(
-            "INSERT INTO word_group (name) VALUES (?1) RETURNING id",
+            "INSERT INTO word_groups (name) VALUES (?1) RETURNING id",
             (&group.name,),
             |row| row.get(0),
         )
@@ -154,7 +154,7 @@ pub fn update_group(group: &mut WordGroup, connection: &Connection) -> MaybeErro
     } else {
         connection
             .execute(
-                "UPDATE word_group SET name = ?1 WHERE id = ?2",
+                "UPDATE word_groups SET name = ?1 WHERE id = ?2",
                 (&group.name, &group.id),
             )
             .map_err(|_| DbSaveError)?;
@@ -167,7 +167,7 @@ pub fn delete_group(group: &WordGroup, connection: &Connection) -> MaybeError {
         return Err(DbSaveError);
     }
     connection
-        .execute("DELETE FROM word_group WHERE id = ?1", (&group.id,))
+        .execute("DELETE FROM word_groups WHERE id = ?1", (&group.id,))
         .map_err(|_| DbSaveError)?;
     Ok(())
 }