Fix already updated cache change

Cargo.toml

@@ -4,20 +4,20 @@ version = "0.1.3"
 edition = "2024"
 
 [dependencies]
-iced = { version = "0.14.0", features = ["tokio", "svg", "lazy"]}
+iced = { version = "0.14.0", features = ["tokio", "svg", "lazy", "crisp", "tiny-skia", "wayland", "wgpu"], default-features = false}
 iced_core = "0.14.0"
 rand = "0.10.2"
-dirs = "6.0.0"
+dirs = "7.0.0"
 serde_json = "1.0.151"
 rhai = { version = "1.26.0", features = ["sync"] }
 chrono = "0.4.45"
 rusqlite = { version = "0.40.2", features = ["chrono", "bundled"] }
-reqwest = { version = "0.13.4", features = ["json", "stream", "multipart"] }
+reqwest = { version = "0.13.5", features = ["json", "stream", "multipart"] }
 rodio = "0.22.2"
 sha2 = "0.11.0"
 tokio = { version = "1.53.1", features = ["rt", "rt-multi-thread", "macros"] }
 hex = "0.4.3"
-zstd = "0.13.3"
+zstd = "0.14.0"
 zip = "8.6.0"
 rfd = "0.17.2"
 mimalloc = "0.1.52"

src/app.rs

@@ -103,6 +103,7 @@ pub fn fill_state(state: &mut AppState) {
     state.dictionary.write().start().unwrap();
     state.decks.write().start().unwrap();
     state.history.write().start().unwrap();
+    state.card_states.write().start().unwrap();
 
     state.sync_data = Arc::new(RwLock::new(setting))
 }

src/core/deck.rs

@@ -1,23 +1,23 @@
-use std::sync::Arc;
-use std::time::Instant;
-use chrono::Utc;
 use crate::app::AppState;
 use crate::core::srs::OrderModule::{Fsrs, RandomSRS, SemiRandomSRS, WorstWordsSRS};
 use crate::core::srs::{
-    OrderMode, OrderModule, RandomSRSModule, SRSModule, SemiRandomSRSModule,
+    FsrsModule, OrderMode, OrderModule, RandomSRSModule, SRSModule, SemiRandomSRSModule,
     WordOpenMode, WorstWordsSRSModule,
 };
 use crate::data::entities::*;
-use crate::data_provider::card_states::{CardStateRepositoryInner};
-use crate::notification::{MaybeError, NotificationData};
+use crate::data::repositories::Repository;
+use crate::data_provider::card_states::CardStateRepositoryInner;
+use crate::notification::MaybeError;
+use chrono::Utc;
 use log::info;
 use rhai::{Engine, Scope};
-use crate::data::repositories::Repository;
+use std::sync::Arc;
+use std::time::Instant;
 
 #[derive(Clone)]
 pub struct DeckData {
     pub(crate) words: Vec<EntityHandle<WordData>>,
-    pub(crate) set: Vec<EntityHandle<CardState>>,
+    pub(crate) states: Vec<EntityHandle<CardState>>,
     current_word_index: Option<usize>,
     state: AppState,
     order_module: OrderModule,
@@ -25,80 +25,58 @@ pub struct DeckData {
     settings: DeckSettings,
 }
 impl DeckData {
-    pub fn new(
-        settings: &DeckSettings,
-        state: AppState,
-    ) -> Result<Self, NotificationData> {
-        todo!()
-        // let state_for = state.clone();
-        //
-        // let stats = state (settings, &state.connection.read())?;
-        // let words = stats
-        //     .iter()
-        //     .map(|stat| {
-        //         state
-        //             .dictionary
-        //             .binary_search_by_key(&stat.word_id, |w| w.id)
-        //             .expect("No word found in dictionary")
-        //     })
-        //     .map(|index| &state.dictionary[index])
-        //     .cloned()
-        //     .collect();
-        //
-        // Ok(Self {
-        //     set: stats,
-        //     words,
-        //     current_word_index: None,
-        //     state: state_for,
-        //     order_module: Fsrs(FsrsModule::new()),
-        //     open_mode: settings.open_mode,
-        //     settings: settings.clone(),
-        // })
+    pub fn new(settings: &DeckSettings, open_mode: OrderMode, state: AppState) -> Self {
+        let states_repo = state.card_states.read();
+        let mut query = states_repo.deck_states(settings.id);
+        let words = query
+            .iter(&states_repo)
+            .map(|card_state| EntityHandle::from_id(card_state.word_id))
+            .collect();
+        let states = query.handles().collect::<Vec<EntityHandle<CardState>>>();
+        let fsrs = Fsrs(FsrsModule::new(Self::set_links(states.as_slice(), &states_repo).as_slice()));
+        drop(states_repo);
+        Self {
+            states,
+            words,
+            current_word_index: None,
+            state,
+            order_module: fsrs,
+            open_mode,
+            settings: settings.clone(),
+        }
     }
 
     pub fn next(&mut self) -> (EntityHandle<WordData>, EntityHandle<CardState>) {
+        if self.fsrs_finished() {
+            self.switch_order_engine()
+        }
         let repo = self.state.card_states.read();
-        let links = Self::set_links(self.set.as_slice(), &repo);
+        let links = Self::set_links(self.states.as_slice(), &repo);
         let index = match self.order_module {
-            SemiRandomSRS(ref mut module) => {
-                if !module.initialized {
-                    module.init(links.as_slice());
-                }
-                module.next(links.as_slice())
-            }
+            SemiRandomSRS(ref mut module) => module.next(links.as_slice()),
 
-            RandomSRS(ref mut module) => {
-                if !module.initialized {
-                    module.init(links.as_slice())
-                }
-                module.next(links.as_slice())
-            }
-            WorstWordsSRS(ref mut module) => {
-                if !module.initialized {
-                    module.init(links.as_slice())
-                }
-                module.next(links.as_slice())
-            }
-            Fsrs(ref mut module) => {
-                if !module.initialized {
-                    module.init(links.as_slice())
-                }
-                module.next(links.as_slice())
-            }
+            RandomSRS(ref mut module) => module.next(links.as_slice()),
+            WorstWordsSRS(ref mut module) => module.next(links.as_slice()),
+            Fsrs(ref mut module) => module.next(links.as_slice()),
         };
 
         self.current_word_index = Some(index);
-        (self.words[index].clone(), self.set[index].clone())
+        (self.words[index].clone(), self.states[index].clone())
     }
 
-    fn set_links<'a>(set: &[EntityHandle<CardState>], repo: &'a CardStateRepositoryInner) -> Vec<&'a CardState>  {
-        set.iter().map(|h| repo.get_ref_static(*h).unwrap()).collect::<Vec<_>>()
+    fn set_links<'a>(
+        set: &[EntityHandle<CardState>],
+        repo: &'a CardStateRepositoryInner,
+    ) -> Vec<&'a CardState> {
+        set.iter()
+            .map(|h| repo.get_ref_static(*h).unwrap())
+            .collect::<Vec<_>>()
     }
 
     pub fn open(&mut self, status: WordOpenMode) -> MaybeError {
         if let Some(index) = self.current_word_index {
             let mut repo = self.state.card_states.write();
-            let card_state_handle = &mut self.set[index];
+            let card_state_handle = &mut self.states[index];
             let card_state = repo.get_mut(card_state_handle).unwrap();
             let old_score = card_state.score;
             card_state.update(status);
@@ -121,16 +99,6 @@ impl DeckData {
                 }
             }
 
-            if let Fsrs(ref fsrs) = self.order_module
-                && fsrs.finished()
-            {
-                self.order_module = match self.open_mode {
-                    OrderMode::Default => SemiRandomSRS(SemiRandomSRSModule::new()),
-                    OrderMode::TrainWorstFirst => WorstWordsSRS(WorstWordsSRSModule::new()),
-                    OrderMode::FullRandom => RandomSRS(RandomSRSModule::new()),
-                }
-            }
-
             let word_id = card_state.word_id;
             repo.save(card_state_handle)?;
 
@@ -145,23 +113,34 @@ impl DeckData {
                 after: new_score,
                 fsrs,
             })?;
-            todo!("Implement history pushing")
-            // let _ = push_note(
-            //     self.settings.id,
-            //     HistoryNote {
-            //         timestamp: Utc::now(),
-            //         word_id: word.word_id,
-            //         answer: status,
-            //         before: old_score,
-            //         after: new_score,
-            //     },
-            // );
         }
 
         Ok(())
     }
+
+    fn switch_order_engine(&mut self) {
+        let repo = self.state.card_states.read();
+        let links = Self::set_links(self.states.as_slice(), &repo);
+        self.order_module = match self.open_mode {
+            OrderMode::Default => SemiRandomSRS(SemiRandomSRSModule::new(links.as_slice())),
+            OrderMode::TrainWorstFirst => WorstWordsSRS(WorstWordsSRSModule::new(links.as_slice())),
+            OrderMode::FullRandom => RandomSRS(RandomSRSModule::new(links.as_slice())),
+        }
+    }
+
+    fn fsrs_finished(&self) -> bool {
+        if let Fsrs(ref fsrs) = self.order_module
+            && fsrs.finished()
+        {
+            info!("Fsrs finished. Infinite mode enabled");
+            return true;
+        }
+
+        false
+    }
+
     pub fn len(&self) -> usize {
-        self.set.len()
+        self.states.len()
     }
 
     pub fn list(deck: &DeckSettings, state: &AppState) -> Vec<EntityHandle<WordData>> {
@@ -179,17 +158,18 @@ impl DeckData {
                     more.insert(iced.0.clone().into(), iced.1.clone().into());
                 }
                 let mut scope = Scope::new();
-                let group_name = groups[groups.binary_search_by_key(&word.group_id, |g| g.id).unwrap()].name.clone();
+                let group_name = groups[groups
+                    .binary_search_by_key(&word.group_id, |g| g.id)
+                    .unwrap()]
+                .name
+                .clone();
                 scope
                     .push_constant("id", word.id.0 as i64)
                     .push_constant("key", word.key.clone())
                     .push_constant("value", word.value.clone())
                     .push_constant("tags", word.tags.clone())
                     .push_constant("more", more)
-                    .push_constant(
-                        "group",
-                        group_name,
-                    );
+                    .push_constant("group", group_name);
 
                 let result = engine.eval_ast_with_scope::<bool>(&mut scope, &ast);
                 if let Ok(result) = result {

src/core/srs.rs

@@ -1,6 +1,7 @@
 use crate::data::entities::CardState;
 use chrono::{Local, TimeDelta};
 use fsrs::FSRS;
+use log::{debug, info};
 use rand::distr::weighted::WeightedIndex;
 use rand::prelude::ThreadRng;
 use rand::prelude::{Distribution, SliceRandom};
@@ -31,24 +32,23 @@ pub enum OrderModule {
     Fsrs(FsrsModule),
 }
 pub trait SRSModule {
+    fn new(set: &[&CardState]) -> Self;
     fn next(&mut self, set: &[&CardState]) -> usize;
     fn open(&mut self, status: WordOpenMode, index: usize, updated_word: &mut CardState);
-    fn init(&mut self, set: &[&CardState]);
 }
 #[derive(Clone)]
 pub struct RandomSRSModule {
     basket: Vec<usize>,
-    pub(crate) initialized: bool,
-}
-impl RandomSRSModule {
-    pub(crate) fn new() -> RandomSRSModule {
-        Self {
-            basket: vec![],
-            initialized: false,
-        }
-    }
 }
 impl SRSModule for RandomSRSModule {
+    fn new(set: &[&CardState]) -> Self {
+        let mut basket = (0..set.len()).collect::<Vec<usize>>();
+        basket.shuffle(&mut rand::rng());
+        Self{
+            basket,
+        }
+    }
+
     fn next(&mut self, set: &[&CardState]) -> usize {
         match self.basket.pop() {
             Some(index) => index,
@@ -61,29 +61,12 @@ impl SRSModule for RandomSRSModule {
     }
 
     fn open(&mut self, _: WordOpenMode, _: usize, _: &mut CardState) {}
-
-    fn init(&mut self, set: &[&CardState]) {
-        self.initialized = true;
-        self.basket = (0..set.len()).collect::<Vec<usize>>();
-        self.basket.shuffle(&mut rand::rng())
-    }
 }
 #[derive(Clone)]
 pub struct SemiRandomSRSModule {
     history: Vec<usize>,
     last_weights: WeightedIndex<f32>,
     generator: ThreadRng,
-    pub(crate) initialized: bool,
-}
-impl SemiRandomSRSModule {
-    pub(crate) fn new() -> SemiRandomSRSModule {
-        SemiRandomSRSModule {
-            history: vec![],
-            last_weights: WeightedIndex::new([1.0]).unwrap(),
-            generator: rng(),
-            initialized: false,
-        }
-    }
 }
 impl SRSModule for SemiRandomSRSModule {
     fn next(&mut self, set: &[&CardState]) -> usize {
@@ -106,13 +89,18 @@ impl SRSModule for SemiRandomSRSModule {
             .update_weights(&[(index, &new_weight)])
             .expect("update weights error");
     }
-    fn init(&mut self, set: &[&CardState]) {
-        self.initialized = true;
+    fn new(set: &[&CardState]) -> Self {
+
         let weights = set
             .iter()
             .map(|s| (100.0 / s.calculated_score()).powf(2.0) * 2.0)
             .collect::<Vec<f32>>();
-        self.last_weights = WeightedIndex::new(weights).expect("Incorrect weights update");
+
+        Self{
+            generator: rng(),
+            last_weights:  WeightedIndex::new(weights).expect("Incorrect weights update"),
+            history: vec![]
+        }
     }
 }
 impl SemiRandomSRSModule {
@@ -122,7 +110,6 @@ impl SemiRandomSRSModule {
 }
 #[derive(Clone)]
 pub struct WorstWordsSRSModule {
-    pub(crate) initialized: bool,
     pool_size: usize,
     rounds_remaining: u8,
     pool: Vec<usize>,
@@ -148,14 +135,8 @@ impl SRSModule for WorstWordsSRSModule {
 
     fn open(&mut self, _: WordOpenMode, _: usize, _: &mut CardState) {}
 
-    fn init(&mut self, _: &[&CardState]) {
-        self.initialized = true;
-    }
-}
-impl WorstWordsSRSModule {
-    pub(crate) fn new() -> WorstWordsSRSModule {
+    fn new(_: &[&CardState]) -> Self {
         WorstWordsSRSModule {
-            initialized: false,
             pool_size: PARTIAL_POOL_SIZE,
             rounds_count: 2,
             rounds_remaining: 0,
@@ -163,6 +144,8 @@ impl WorstWordsSRSModule {
             queue: vec![],
         }
     }
+}
+impl WorstWordsSRSModule {
     fn fill_pool(&mut self, set: &[&CardState]) {
         let mut sorted = set.iter().enumerate().collect::<Vec<_>>();
         sorted.sort_by_key(|c| c.1.score);
@@ -183,10 +166,31 @@ pub struct FsrsModule {
     queue: Vec<usize>,
     rng: ThreadRng,
     fsrs: FSRS,
-    pub(crate) initialized: bool,
 }
 
 impl SRSModule for FsrsModule {
+    fn new(set: &[&CardState]) -> Self {
+        let today = Local::now().date_naive();
+
+        let mut new = Self {
+            today_set: set
+                .iter()
+                .enumerate()
+                .filter(|(_, c)| c.fsrs_open_day <= today)
+                .map(|(index, _)| index)
+                .collect(),
+            current_group: vec![],
+            queue: vec![],
+            solved: vec![],
+            rng: rng(),
+            fsrs: FSRS::default(),
+        };
+        new.today_set.shuffle(&mut new.rng);
+        new.fill_partial_pool();
+
+        new
+    }
+
     fn next(&mut self, _: &[&CardState]) -> usize {
         if self.current_group.is_empty() {
             self.fill_partial_pool();
@@ -222,45 +226,25 @@ impl SRSModule for FsrsModule {
             let offset = ((rng().random::<f32>() - 0.5) * 3.0).round() as i32;
             next_day += TimeDelta::days(offset as i64);
         }
+
+        let first_time = updated_word.fsrs_memory.is_none();
+
         updated_word.fsrs_memory = Some(next.memory);
         updated_word.fsrs_open_day = next_day;
         updated_word.fsrs_opened = updated_word.last_open.date_naive();
 
-        if updated_word.fsrs_open_day != today {
+        if (updated_word.fsrs_open_day != today && !first_time) || (first_time && status == WordOpenMode::Easy) {
+            info!("For today word on index {} solved", index);
             self.solved.push(index);
             let index = self.current_group.iter().position(|x| *x == index).unwrap();
             self.current_group.remove(index);
         }
     }
-
-    fn init(&mut self, set: &[&CardState]) {
-        self.rng = rng();
-        let today = Local::now().date_naive();
-        self.today_set = set
-            .iter()
-            .enumerate()
-            .filter(|(_, c)| c.fsrs_open_day <= today)
-            .map(|(index, _)| index)
-            .collect();
-        self.today_set.shuffle(&mut self.rng);
-        self.fill_partial_pool();
-        self.initialized = true;
-    }
 }
 
 impl FsrsModule {
-    pub fn new() -> Self {
-        Self {
-            today_set: vec![],
-            current_group: vec![],
-            queue: vec![],
-            solved: vec![],
-            rng: Default::default(),
-            fsrs: FSRS::default(),
-            initialized: false,
-        }
-    }
     fn fill_partial_pool(&mut self) {
+        debug!("Filling partial pool");
         self.current_group.extend(
             self.today_set
                 .iter()
@@ -281,7 +265,7 @@ impl FsrsModule {
     }
 }
 
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 pub enum WordOpenMode {
     Easy,
     Ok,

src/data/repositories.rs

@@ -11,6 +11,8 @@ use rusqlite::Connection;
 use std::marker::PhantomData;
 use std::ops::{Deref, Index, IndexMut};
 use std::sync::Arc;
+use std::time::Instant;
+use log::debug;
 
 pub trait Repository<T, D>
 where
@@ -158,6 +160,7 @@ impl<T: EntityData + Clone + Send + Sync, R: Repository<T, D>, D: DbLayer<T>> Qu
     where
         T: Send + Sync,
     {
+        let time = Instant::now();
         self.cache.clear();
         if self.parallel {
             self.cache = data_repository
@@ -186,6 +189,8 @@ impl<T: EntityData + Clone + Send + Sync, R: Repository<T, D>, D: DbLayer<T>> Qu
                 .map(|(i, entity)| EntityHandle::new(entity.id(), i, false))
                 .collect::<Vec<_>>(),
         );
+
+        debug!("Query for {} elements (filtered {}) takes {:?}", data_repository.len(), self.cache.len(), time.elapsed());
     }
 
     pub fn handles(&self) -> impl Iterator<Item = EntityHandle<T>> {
@@ -278,7 +283,7 @@ impl<T: Clone + EntityData, D: DbLayer<T>> Deref for DataRepository<T, D> {
     }
 }
 
-impl<T: EntityData + Clone, D: DbLayer<T>> DataRepositoryInner<T, D> {
+impl<T: EntityData + Clone + std::marker::Send + std::marker::Sync, D: DbLayer<T>> DataRepositoryInner<T, D> {
     pub fn query_par(
         &self,
         rule: Arc<dyn Fn(&T) -> bool + Send + Sync>,
@@ -286,30 +291,17 @@ impl<T: EntityData + Clone, D: DbLayer<T>> DataRepositoryInner<T, D> {
     where
         T: Send + Sync,
     {
-        let mut cache: Vec<EntityHandle<T>> = self
-            .cache
-            .par_iter()
-            .enumerate()
-            .filter(|(_, entity)| rule(entity))
-            .map(|(i, entity)| EntityHandle::new(entity.id(), i, true))
-            .collect();
-
-        cache.extend(
-            self.temporal
-                .iter()
-                .enumerate()
-                .filter(|(_, entity)| rule(entity))
-                .map(|(i, entity)| EntityHandle::new(entity.id(), i, false))
-                .collect::<Vec<_>>(),
-        );
-
-        Query {
-            cache,
+        let mut query = Query {
+            cache: vec![],
             rule,
             parallel: true,
             _marker: PhantomData,
             shift_stamp: self.shifts,
-        }
+        };
+
+        query.load(self);
+
+        query
     }
 
     pub fn query(
@@ -319,30 +311,17 @@ impl<T: EntityData + Clone, D: DbLayer<T>> DataRepositoryInner<T, D> {
     where
         T: Send + Sync,
     {
-        let mut cache: Vec<EntityHandle<T>> = self
-            .cache
-            .iter()
-            .enumerate()
-            .filter(|(_, entity)| rule(entity))
-            .map(|(i, entity)| EntityHandle::new(entity.id(), i, true))
-            .collect();
-
-        cache.extend(
-            self.temporal
-                .iter()
-                .enumerate()
-                .filter(|(_, entity)| rule(entity))
-                .map(|(i, entity)| EntityHandle::new(entity.id(), i, false))
-                .collect::<Vec<_>>(),
-        );
-
-        Query {
-            cache,
+        let mut query = Query {
+            cache: vec![],
             rule,
             parallel: false,
             _marker: PhantomData,
             shift_stamp: self.shifts,
-        }
+        };
+
+        query.load(self);
+
+        query
     }
     
     pub fn empty_query(&self) -> Query<T, DataRepositoryInner<T, D>, D> {
@@ -365,6 +344,10 @@ impl<T: EntityData + Clone, D: DbLayer<T>> DataRepositoryInner<T, D> {
         }
     }
 
+    pub fn full_query(&self) -> Query<T, DataRepositoryInner<T, D>, D> {
+        self.query(Arc::new(|_| true))
+    }
+
     pub fn len(&self) -> usize {
         self.cache.len() + self.temporal.len()
     }

src/data_provider/card_states.rs

@@ -1,4 +1,6 @@
+use std::sync::Arc;
 use crate::data::entities::{CardState, DeckSettings};
+use crate::data::repositories::{DataRepository, DataRepositoryInner, Query};
 use crate::data_provider::{SqliteDbLayer, TableAccessQuerySet};
 use crate::notification::NotificationData::{DbLoadError, DbSaveError};
 use crate::notification::{MaybeError, NotificationData};
@@ -7,10 +9,13 @@ use fsrs::MemoryState;
 use log::info;
 use rusqlite::{Connection, Error, Params, Row, params};
 use std::time::Instant;
-use crate::data::repositories::{DataRepository, DataRepositoryInner};
+use crate::data::Id;
 
-pub type CardStateRepository = DataRepository<CardState, SqliteDbLayer<CardState, CardStatesQuerySet>>;
-pub type CardStateRepositoryInner = DataRepositoryInner<CardState, SqliteDbLayer<CardState, CardStatesQuerySet>>;
+pub type CardStateRepository =
+    DataRepository<CardState, CardStateDbLayer>;
+pub type CardStateRepositoryInner =
+    DataRepositoryInner<CardState, CardStateDbLayer>;
+pub type CardStateDbLayer = SqliteDbLayer<CardState, CardStatesQuerySet>;
 #[derive(Clone)]
 pub struct CardStatesQuerySet;
 impl TableAccessQuerySet<CardState> for CardStatesQuerySet {
@@ -19,11 +24,11 @@ impl TableAccessQuerySet<CardState> for CardStatesQuerySet {
     }
 
     fn save() -> &'static str {
-        "UPDATE states SET score = ?1, last_opened = ?2 WHERE id = ?3"
+        "UPDATE states SET score = ?1, last_opened = ?2, fsrs_opened = ?3, fsrs_memory = ?4, fsrs_open_day = ?5 WHERE id = ?6"
     }
 
     fn add() -> &'static str {
-        "INSERT INTO states (word_id, deck_id, score, last_opened, fsrs_opened, fsrs_memory, fsrs_open_day) VALUES (?1, ?2, ?3, ?4) RETURNING id"
+        "INSERT INTO states (word_id, deck_id, score, last_opened, fsrs_opened, fsrs_memory, fsrs_open_day) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)"
     }
 
     fn name() -> &'static str {
@@ -58,7 +63,14 @@ impl TableAccessQuerySet<CardState> for CardStatesQuerySet {
     }
 
     fn update_params(entity: &CardState) -> impl Params {
-        (entity.score, entity.last_open.timestamp(), entity.id)
+        (
+            entity.score,
+            entity.last_open.timestamp(),
+            entity.fsrs_opened.to_epoch_days(),
+            memory_to_i64(&entity.fsrs_memory),
+            entity.fsrs_open_day.to_epoch_days(),
+            entity.id,
+        )
     }
 }
 pub fn load_stats_of_deck(
@@ -109,74 +121,8 @@ fn memory_to_i64(value: &Option<MemoryState>) -> i64 {
     value.stability.to_bits() as i64 | ((value.difficulty.to_bits() as i64) << 32)
 }
 
-pub fn add_stat_list(stats: &mut [CardState], connection: &mut Connection) -> MaybeError {
-    let time = Instant::now();
-    let tx = connection
-        .transaction()
-        .expect("Failed to create transaction");
-    let count = stats.len();
-
-    {
-        let mut stmt = tx
-            .prepare(
-                "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");
-
-        for stat in stats.iter() {
-            stmt.execute(params![
-                stat.word_id,
-                stat.deck_id,
-                stat.score,
-                stat.last_open.timestamp(),
-                stat.fsrs_opened.to_epoch_days(),
-                memory_to_i64(&stat.fsrs_memory),
-                stat.fsrs_open_day.to_epoch_days()
-            ])
-            .map_err(|_| DbSaveError)?;
+impl CardStateRepositoryInner {
+    pub fn deck_states(&self, deck_id: Id) -> Query<CardState, CardStateRepositoryInner, CardStateDbLayer> {
+        self.query(Arc::new(move |state| {state.deck_id == deck_id}))
     }
 }
-
-    let last_index: u32 = tx.last_insert_rowid() as u32;
-    tx.commit().expect("Failed to commit");
-
-    let start_index = last_index - (count as u32) + 1;
-
-    for (index, id) in (start_index..=last_index).enumerate() {
-        stats[index].id = id.into();
-    }
-
-    info!("Added {} cards for {:?}", stats.len(), time.elapsed());
-    Ok(())
-}
-
-pub fn update_stat_score(stat: &CardState, connection: &Connection) -> MaybeError {
-    let time = Instant::now();
-
-    connection
-        .execute(
-            "UPDATE states SET score = ?1, last_opened = ?2 WHERE id = ?3",
-            (&stat.score, &stat.last_open.timestamp(), &stat.id),
-        )
-        .map_err(|_| DbSaveError)?;
-    info!("Updated stat: {}", time.elapsed().as_millis());
-    Ok(())
-}
-
-pub fn delete_stats(stat: &[CardState], connection: &Connection) -> MaybeError {
-    if stat.is_empty() {
-        return Ok(());
-    }
-    let ids = stat
-        .iter()
-        .map(|s| s.id.into())
-        .collect::<Vec<String>>()
-        .join(", ");
-    connection
-        .execute(
-            format!("DELETE FROM states WHERE id in ({ids})").as_str(),
-            (),
-        )
-        .map_err(|_| DbSaveError)?;
-    Ok(())
-}

src/data_provider/custom_fields.rs

@@ -16,7 +16,7 @@ impl TableAccessQuerySet<WordGroup> for CustomFieldsQuerySet {
     }
 
     fn add() -> &'static str {
-        "INSERT INTO word_groups (name) VALUES (?1) RETURNING id"
+        "INSERT INTO word_groups (name) VALUES (?1)"
     }
 
     fn name() -> &'static str {

src/data_provider/decks.rs

@@ -17,7 +17,7 @@ impl TableAccessQuerySet<DeckSettings> for DeckQuerySet {
     }
 
     fn add() -> &'static str {
-        "INSERT INTO decks (name, forward, backward, filter) VALUES (?1, ?2, ?3, ?4) RETURNING id"
+        "INSERT INTO decks (name, forward, backward, filter) VALUES (?1, ?2, ?3, ?4)"
     }
 
     fn name() -> &'static str {

src/data_provider/history.rs

@@ -21,13 +21,16 @@ impl TableAccessQuerySet<HistoryNote> for HistoryQuerySet {
     }
 
     fn add() -> &'static str {
-        "INSERT INTO history (deck_id, state_id, timestamp, answer, before, after, fsrs) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7) RETURNING rowid"
+        "INSERT INTO history (deck_id, word_id, timestamp, answer, before, after, fsrs) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)"
     }
 
     fn name() -> &'static str {
         "history"
     }
 
+    fn id_field() -> &'static str {
+        "rowid"
+    }
     fn from_sql(row: &Row) -> Result<HistoryNote, Error> {
         Ok(HistoryNote {
             id: row.get(0)?,

src/data_provider/import.rs

@@ -1,7 +1,7 @@
+use std::collections::BTreeMap;
 use crate::helpers::into_result;
 use crate::notification::NotificationData;
 use crate::notification::NotificationData::IncorrectAnkiFile;
-use hashbrown::HashMap;
 use log::info;
 use rusqlite::Connection;
 use serde_json::Value;
@@ -15,7 +15,7 @@ pub struct ImportGroup {
     pub name: String,
     pub fields: Vec<String>,
     pub length: u64,
-    pub mapping: HashMap<String, String>,
+    pub mapping: BTreeMap<String, String>,
     pub imported: bool,
 }
 
@@ -45,7 +45,7 @@ pub fn load_groups(connection: &Connection) -> Result<ImportData, NotificationDa
             .collect::<Vec<(i64, i64)>>();
 
         for (_, collection) in sets {
-            let fields_property = collection.get("fields");
+            let fields_property = collection.get("flds");
             if let Some(fields_property) = fields_property {
                 let fields = into_result(fields_property.as_array(), IncorrectAnkiFile)?
                     .iter()

src/data_provider/mod.rs

@@ -1,8 +1,8 @@
 use crate::data::Id;
-use crate::data::entities::{EntityData};
+use crate::data::entities::EntityData;
 use crate::data::repositories::{BatchedDbLayer, DbLayer};
 use crate::notification::MaybeError;
-use crate::notification::NotificationData::{DbLoadError, DbSaveError};
+use crate::notification::NotificationData::DbSaveError;
 use log::{debug, error};
 use rusqlite::{Connection, Error, Params, Row};
 use std::marker::PhantomData;
@@ -25,6 +25,9 @@ pub trait TableAccessQuerySet<T> {
     fn save() -> &'static str;
     fn add() -> &'static str;
     fn name() -> &'static str;
+    fn id_field() -> &'static str {
+        "id"
+    }
     fn from_sql(row: &Row) -> Result<T, Error>;
     fn insert_params(entity: &T) -> impl Params;
     fn update_params(entity: &T) -> impl Params;
@@ -52,7 +55,10 @@ impl<T: EntityData, Q: TableAccessQuerySet<T>> DbLayer<T> for SqliteDbLayer<T, Q
 
         connection
             .execute(Q::save(), Q::update_params(entity))
-            .map_err(|e| {error!("{}", e); DbSaveError})?;
+            .map_err(|e| {
+                error!("{}", e);
+                DbSaveError
+            })?;
         debug!("Updated in {} for {:?}", Q::name(), time.elapsed());
         Ok(())
     }
@@ -61,8 +67,11 @@ impl<T: EntityData, Q: TableAccessQuerySet<T>> DbLayer<T> for SqliteDbLayer<T, Q
         let time = Instant::now();
 
         let index: u32 = connection
-            .query_row(Q::add(), Q::insert_params(entity), |row| row.get(0))
-            .map_err(|e| {error!("{}", e); DbSaveError})?;
+            .query_row(format!("{} RETURNING {}", Q::add(), Q::id_field()).as_str(), Q::insert_params(entity), |row| row.get(0))
+            .map_err(|e| {
+                error!("{}", e);
+                DbSaveError
+            })?;
 
         entity.set_id(index.into());
         debug!("Added into {} for {:?}", Q::name(), time.elapsed());
@@ -80,7 +89,10 @@ impl<T: EntityData, Q: TableAccessQuerySet<T>> DbLayer<T> for SqliteDbLayer<T, Q
                 format!("DELETE FROM {} WHERE id = ?1", Q::name()).as_str(),
                 (&id,),
             )
-            .map_err(|e| {error!("{}", e); DbSaveError})?;
+            .map_err(|e| {
+                error!("{}", e);
+                DbSaveError
+            })?;
         debug!("Deleted from {} for {:?}", Q::name(), time.elapsed());
         Ok(())
     }
@@ -93,7 +105,10 @@ impl<T: EntityData, Q: TableAccessQuerySet<T>> DbLayer<T> for SqliteDbLayer<T, Q
             .expect("Failed to prepare state query");
         let iter = stmt
             .query_map([], |row| Ok(Q::from_sql(row)?))
-            .map_err(|e| {error!("{}", e); DbSaveError})?;
+            .map_err(|e| {
+                error!("{}", e);
+                DbSaveError
+            })?;
 
         iter.filter_map(|res| res.ok())
             .for_each(|i| storage.push(i));
@@ -123,7 +138,10 @@ impl<T: EntityData, Q: TableAccessQuerySet<T>> BatchedDbLayer<T> for SqliteDbLay
                     format!("DELETE FROM {} WHERE id in ({})", Q::name(), stringed).as_str(),
                     (),
                 )
-                .map_err(|_| DbSaveError)?;
+                .map_err(|e| {
+                    error!("{}", e);
+                    DbSaveError
+                })?;
         }
         debug!(
             "Deleted {} from {} for {:?}",
@@ -145,8 +163,10 @@ impl<T: EntityData, Q: TableAccessQuerySet<T>> BatchedDbLayer<T> for SqliteDbLay
         {
             let mut stmt = tx.prepare(Q::add()).expect("Failed to prepare state query");
             for entity in entities.iter() {
-                stmt.execute(Q::insert_params(entity))
-                    .map_err(|_| DbSaveError)?;
+                stmt.execute(Q::insert_params(entity)).map_err(|e| {
+                    error!("{}", e);
+                    DbSaveError
+                })?;
             }
         }
 

src/data_provider/sqlite.rs

@@ -1,6 +1,7 @@
 use crate::fs::*;
 use rusqlite::Connection;
 use std::ops::{Deref, DerefMut};
+use log::error;
 
 pub fn create_db() {
     let db_file = db_path();
@@ -108,9 +109,27 @@ impl Default for SqliteConnection {
 
 impl SqliteConnection {
     pub fn finish(&mut self) {
+        let connection = self.0.take().unwrap();
+        connection
+            .query_row("PRAGMA wal_checkpoint(TRUNCATE)", [], |_| Ok(()))
+            .unwrap_or_else(|e| {
+                error!("Ошибка при checkpoint WAL: {e}");
+            });
+        connection
+            .execute("PRAGMA optimize", [])
+            .unwrap_or_else(|e| {
+                error!("Ошибка при  оптимизации БД: {e}");
+                0
+            });
+
         self.0 = None;
     }
     pub fn restart(&mut self) {
         self.0 = Some(default_connection());
     }
 }
+
+impl Drop for SqliteConnection {
+
+fn drop(&mut self) { self.finish(); }
+}

src/data_provider/word_groups.rs

@@ -19,7 +19,7 @@ impl TableAccessQuerySet<WordGroup> for WordGroupQuerySet {
     }
 
     fn add() -> &'static str {
-        "INSERT INTO word_groups (name) VALUES (?1) RETURNING id"
+        "INSERT INTO word_groups (name) VALUES (?1)"
     }
 
     fn name() -> &'static str {

src/data_provider/words.rs

@@ -20,7 +20,7 @@ impl TableAccessQuerySet<WordData> for WordQuerySet {
     }
 
     fn add() -> &'static str {
-        "INSERT INTO words (key, value, tags, more, group_id) VALUES (?1, ?2, ?3, ?4, ?5) RETURNING id"
+        "INSERT INTO words (key, value, tags, more, group_id) VALUES (?1, ?2, ?3, ?4, ?5)"
     }
 
     fn name() -> &'static str {
@@ -63,7 +63,7 @@ impl TableAccessQuerySet<WordData> for WordQuerySet {
 pub fn add_word(word: &mut WordData, connection: &Connection) -> MaybeError {
     let index : u32 = connection
         .query_row(
-            "INSERT INTO words (key, value, tags, more, group_id) VALUES (?1, ?2, ?3, ?4, ?5) RETURNING id",
+            "INSERT INTO words (key, value, tags, more, group_id) VALUES (?1, ?2, ?3, ?4, ?5)",
             (
                 &word.key,
                 &word.value,
@@ -193,7 +193,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_groups (name) VALUES (?1) RETURNING id",
+            "INSERT INTO word_groups (name) VALUES (?1)",
             (&group.name,),
             |row| row.get(0),
         )

src/pages/dictionary.rs

@@ -2,6 +2,7 @@ use crate::app::AppState;
 use crate::data::Id;
 use crate::data::entities::{EntityHandle, WordData, WordGroup};
 use crate::data::repositories::{Query, Repository};
+use crate::data_provider::word_groups::{WordGroupDataLayer, WordGroupRepositoryInner};
 use crate::data_provider::words::WordDataLayer;
 use crate::data_provider::words::WordRepositoryInner;
 use crate::navigation::Page::{Import, Word};
@@ -28,7 +29,6 @@ use rand::random_range;
 use std::ops::Add;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
-use crate::data_provider::word_groups::{WordGroupDataLayer, WordGroupRepositoryInner};
 
 pub struct DictionaryState {
     state: AppState,
@@ -89,7 +89,7 @@ impl NavigatedPage<DictionaryMessage> for DictionaryState {
                 words,
                 self.reverse,
                 self.no_typing,
-                self.state.clone()
+                self.state.clone(),
             )));
         }
         if let WordAction(handle) = message
@@ -106,6 +106,9 @@ impl NavigatedPage<DictionaryMessage> for DictionaryState {
     fn navigated(&mut self) {
         self.included = Default::default();
         self.tag_map = Default::default();
+        let groups = self.state.word_groups.read();
+        self.groups_query.load(&groups);
+        drop(groups);
         self.update_tags();
     }
 
@@ -116,6 +119,7 @@ impl NavigatedPage<DictionaryMessage> for DictionaryState {
                 let mut word = WordData::new();
                 word.group_id = self.selected_group.id;
                 dictionary.create(word);
+                self.displayed_words_query.load(&dictionary);
             }
 
             SetKey(handle, v) => {
@@ -158,6 +162,8 @@ impl NavigatedPage<DictionaryMessage> for DictionaryState {
                 if let Err(err) = dictionary.delete(i) {
                     return push_error_task!(err);
                 }
+
+                self.displayed_words_query.load(&dictionary);
             }
             Include(i, b) => {
                 if b {
@@ -188,6 +194,7 @@ impl NavigatedPage<DictionaryMessage> for DictionaryState {
                     id: 0.into(),
                     name: format!("Группа слов {}", random_range(100..1000)),
                 });
+                self.groups_query.load(&groups);
             }
             EditGroup(new) => {
                 let mut groups = self.state.word_groups.write();
@@ -198,14 +205,21 @@ impl NavigatedPage<DictionaryMessage> for DictionaryState {
                 }
             }
             SaveGroup => {
+                {
                     let mut groups = self.state.word_groups.write();
 
                     if let Err(err) = groups.save(&mut self.selected_group) {
                         return push_error_task!(err);
                     }
+
+                    self.groups_query.load(&groups);
+                }
+
+                self.setup_words_query();
             }
             SelectGroup(i) => {
                 self.selected_group = i;
+                self.setup_words_query();
                 self.update_words_include(i.id)
             }
             DeleteGroup => {
@@ -213,9 +227,10 @@ impl NavigatedPage<DictionaryMessage> for DictionaryState {
                     return Task::none();
                 }
                 {
-                    let mut groups = self.state.word_groups.write();
                     let delete_group = self.selected_group;
-                    self.selected_group = groups.handle_by_id(Id(1));
+                    self.selected_group = EntityHandle::from_id(1.into());
+                    self.setup_words_query();
+                    let mut groups = self.state.word_groups.write();
 
                     if let Err(err) = groups.delete(delete_group) {
                         return push_error_task!(err);
@@ -224,6 +239,7 @@ impl NavigatedPage<DictionaryMessage> for DictionaryState {
                     if let Err(err) = self.state.dictionary.write().reload() {
                         return push_error_task!(err);
                     }
+                    self.groups_query.load(&groups);
                 }
 
                 self.update_tags()
@@ -241,7 +257,11 @@ impl NavigatedPage<DictionaryMessage> for DictionaryState {
 
                     let mut dictionary = self.state.dictionary.write();
 
+                    let reload_query = handle.real() == false;
                     let _ = dictionary.save(&mut handle);
+                    if reload_query {
+                        self.displayed_words_query.load(&dictionary);
+                    }
                     return Task::none();
                 }
             }
@@ -299,11 +319,20 @@ impl DictionaryState {
     }
 
     fn init(&mut self) {
-        self.displayed_words_query = self.state.dictionary.read().query_par(Arc::new(|word| word.group_id == Id(1)));
+        self.displayed_words_query = self
+            .state
+            .dictionary
+            .read()
+            .query(Arc::new(|word| word.group_id == Id(1)));
     }
 
-    fn setup_words_query(&mut self, id: Id) {
-        // self.displayed_words_query = self.state.dictionary.read().query_par(Arc::new(|word| word.group_id == Self::get_id(self)));
+    fn setup_words_query(&mut self) {
+        let id = self.selected_group.id;
+        self.displayed_words_query = self
+            .state
+            .dictionary
+            .read()
+            .query(Arc::new(move |word| word.group_id == id));
     }
 
     fn launch_auto_save_offset(&mut self, handle: EntityHandle<WordData>) -> Task<RootMessage> {
@@ -317,63 +346,60 @@ impl DictionaryState {
     }
 
     fn words_list(&self) -> iced::Element<'_, DictionaryMessage> {
-        todo!("Make new display system")
-        // let time = Instant::now();
-        // let mut col = Column::new().width(Fill);
-        //
-        // let query = &self.displayed_words_query;
-        // let dictionary = self.state.dictionary.read();
-        //
-        //
-        // for access_index in 0..query.len() {
-        //     let mut i = access_index;
-        //     if self.reverse_list {
-        //         i = query.len() - access_index - 1;
-        //     }
-        //     let word_handle = &query[i];
-        //     let word = dictionary.get_ref_static(*word_handle).unwrap();
-        //
-        //     if !self.search.is_empty()
-        //         && !word.key.contains(&self.search)
-        //         && !word.value.contains(&self.search)
-        //         && !word.tags.contains(&self.search)
-        //     {
-        //         continue;
-        //     }
-        //
-        //     let word_line_data = WordLineState {
-        //         is_included: self.included.contains(word_handle),
-        //         key: word.key.clone().into(),
-        //         value: word.value.clone().into(),
-        //         tags: word.tags.clone().into(),
-        //         handle: word_handle.clone(),
-        //     };
-        //
-        //
-        //     let lazy_line = lazy(word_line_data, |data: &WordLineState| Self::word_line(data));
-        //
-        //     col = col.push(lazy_line);
-        // }
-        //
-        // info!("Words rendering time: {:?}", time.elapsed());
-        // scrollable(col).height(Fill).into()
+        let time = Instant::now();
+        let mut col = Column::new().width(Fill);
+
+        let query = &self.displayed_words_query;
+        let dictionary = self.state.dictionary.read();
+
+        for access_index in 0..query.len() {
+            let mut i = access_index;
+            if self.reverse_list {
+                i = query.len() - access_index - 1;
+            }
+            let word_handle = &query[i];
+            let word = dictionary.get_ref_static(*word_handle).unwrap();
+
+            if !self.search.is_empty()
+                && !word.key.contains(&self.search)
+                && !word.value.contains(&self.search)
+                && !word.tags.contains(&self.search)
+            {
+                continue;
             }
 
-    pub fn word_line(data: &WordLineState) -> Row<'_, DictionaryMessage>
-    {
+            let word_line_data = WordLineState {
+                is_included: self.included.contains(word_handle),
+                key: word.key.clone().into(),
+                value: word.value.clone().into(),
+                tags: word.tags.clone().into(),
+                handle: word_handle.clone(),
+            };
+
+            let lazy_line = lazy(word_line_data, Self::word_line);
+
+            col = col.push(lazy_line);
+        }
+
+        info!("Words rendering time: {:?}", time.elapsed());
+        scrollable(col).height(Fill).into()
+    }
+
+    fn word_line<'a>(data: &WordLineState) -> Row<'a, DictionaryMessage> {
         let mut line = Row::new().width(Fill).align_y(Center);
+        let handle = data.handle.clone();
         line = line.push(
             checkbox(data.is_included)
                 .label("")
                 .spacing(15)
-                .on_toggle(move |b| Include(data.handle, b)),
+                .on_toggle(move |b| Include(handle, b)),
         );
 
         line = line.push(
             text_input("Слово", &data.key)
                 .size(ACCENT_FONT_SIZE)
                 .width(Fill)
-                .on_input(move |string| SetKey(data.handle, string))
+                .on_input(move |string| SetKey(handle, string))
                 .style(|x, status| {
                     let mut default_style = default(x, status);
                     default_style.border.radius = 0.0.into();
@@ -384,7 +410,7 @@ impl DictionaryState {
             text_input("Перевод", &data.value)
                 .size(ACCENT_FONT_SIZE)
                 .width(Fill)
-                .on_input(move |string| SetValue(data.handle, string))
+                .on_input(move |string| SetValue(handle, string))
                 .style(|x, status| {
                     let mut default_style = default(x, status);
                     default_style.border.radius = 0.0.into();
@@ -396,7 +422,7 @@ impl DictionaryState {
             text_input("Теги", data.tags.as_ref())
                 .size(ACCENT_FONT_SIZE)
                 .width(Fill)
-                .on_input(move |string| SetTags(data.handle, string))
+                .on_input(move |string| SetTags(handle, string))
                 .style(|x, status| {
                     let mut default_style = default(x, status);
                     default_style.border.radius = 0.0.into();
@@ -408,13 +434,15 @@ impl DictionaryState {
             if !data.handle.real() {
                 return button("-")
                     .on_press(WordAction(data.handle))
-                    .style(|_x: &iced::Theme, _status: iced::widget::button::Status| Style {
+                    .style(
+                        |_x: &iced::Theme, _status: iced::widget::button::Status| Style {
                             background: None,
                             text_color: Color::BLACK,
                             border: Border::default(),
                             shadow: Shadow::default(),
                             snap: false,
-                    })
+                        },
+                    )
                     .width(15);
             }
 
@@ -434,10 +462,7 @@ impl DictionaryState {
                 .on_input(Search)
                 .width(Fill),
             text!("Всего слов: {}", dict.len()),
-            text!(
-                "Выбрано слов: {}",
-                self.included.iter().count()
-            ),
+            text!("Выбрано слов: {}", self.included.iter().count()),
             self.tags_selector(),
             toggler(self.no_typing)
                 .label("Без набора")
@@ -482,15 +507,19 @@ impl DictionaryState {
     }
 
     fn update_tags(&mut self) {
+        self.words_tags.clear();
         let mut tags_list: HashSet<String> = HashSet::new();
         let dict = &self.state.dictionary.write();
-
-        dict.iter().for_each(|element| {
-            split_with_coma(element.tags.as_str())
-                .iter()
+        let mut words_query = dict.full_query();
+        let handles = words_query.handles().collect::<Vec<_>>();
+        words_query.iter(dict).zip(handles).for_each(|(element, handle)| {
+            let tags = split_with_coma(element.tags.as_str());
+                tags.iter()
                 .for_each(|tag| {
                     tags_list.insert(tag.clone());
                 });
+            self.words_tags.push((handle, tags))
+
         });
 
         let current_tags = self
@@ -534,12 +563,10 @@ impl DictionaryState {
                     continue;
                 }
 
-                if !tags.is_empty()
-                    && tags.iter().all(|t| include_tags.contains(t)) {
+                if !tags.is_empty() && tags.iter().all(|t| include_tags.contains(t)) {
                     self.included.insert(*handle);
                 }
-            }
-            else {
+            } else {
                 continue;
             }
         }

src/pages/repetition.rs

@@ -2,11 +2,13 @@ use crate::app::AppState;
 use crate::core::deck::DeckData;
 use crate::core::srs::WordOpenMode;
 use crate::data::Id;
-use crate::data::entities::{CardState, DeckSettings, WordData};
+use crate::data::entities::{CardState, WordData};
+use crate::data::repositories::Repository;
 use crate::data_provider::voice::get_voice;
 use crate::navigation::Page::PreviousPage;
 use crate::navigation::{KeyPressedPage, NavigatedPage, Page, RootMessage};
 use crate::notification::{MaybeError, NotificationData};
+use crate::pages::repetitions::DeckRunData;
 use crate::styling::*;
 use crate::{push_error, push_error_task};
 use iced::alignment::Horizontal::Center;
@@ -18,11 +20,10 @@ use rodio::MixerDeviceSink;
 use std::collections::HashSet;
 use std::sync::Arc;
 use tokio::task::spawn_blocking;
-use crate::data::repositories::Repository;
 
 pub struct RepetitionState {
     state: AppState,
-    pub settings: DeckSettings,
+    pub settings: DeckRunData,
     pub set: DeckData,
     current_word: WordData,
     current_statistic: CardState,
@@ -102,10 +103,10 @@ impl NavigatedPage<RepetitionMessage> for RepetitionState {
 
 impl RepetitionState {
     pub(crate) fn new(
-        set: DeckSettings,
+        set: DeckRunData,
         state: AppState,
     ) -> Result<RepetitionState, NotificationData> {
-        let mut card_set = DeckData::new(&set, state.clone())?;
+        let mut card_set = DeckData::new(&set, set.open_mode, state.clone());
         let (word, stat) = card_set.next();
         let word = state.dictionary.read().get_static(word).unwrap();
         let stat = state.card_states.read().get_static(stat).unwrap();

src/pages/repetition_settings.rs

@@ -9,6 +9,7 @@ use crate::pages::repetition_settings::RepetitionSettingsMessage::*;
 use crate::styling::*;
 use crate::{push_error, push_error_task};
 use iced::widget::button::danger;
+use iced::widget::space::horizontal;
 use iced::widget::text_input::Catalog;
 use iced::widget::{button, column, row, scrollable, space, text, text_input};
 use iced::{Element, Task};
@@ -22,6 +23,7 @@ pub struct RepetitionSettingsState {
     settings_data: DeckSettings,
     state: AppState,
     real_delete: bool,
+    real_delete_states: bool,
     correct_filter: bool,
     filter_changed: bool,
     filtered_words: Option<u32>,
@@ -38,6 +40,7 @@ impl RepetitionSettingsState {
             settings_handle: settings,
             state,
             real_delete: false,
+            real_delete_states: false,
             correct_filter: true,
             filter_changed: false,
             filtered_words: None,
@@ -105,7 +108,26 @@ impl NavigatedPage<RepetitionSettingsMessage> for RepetitionSettingsState {
 
                 return Task::done(RootMessage::RepetitionSettings(Back));
             }
-            RevertDeleteSet => self.real_delete = false,
+            RevertDeleteSet => {
+                self.real_delete = false;
+                self.real_delete_states = true;
+            }
+            DeleteStates => {
+                if !self.real_delete_states {
+                    self.real_delete_states = true;
+                    return Task::future(async {
+                        tokio::time::sleep(Duration::from_millis(3000)).await;
+                        RootMessage::RepetitionSettings(RevertDeleteSet)
+                    });
+                }
+                let mut states = self.state.card_states.write();
+                let deck_id = self.settings_handle.id;
+                let mut query = states.query(Arc::new(move |state| {state.deck_id == deck_id})).handles().collect::<Vec<_>>();
+                if let Err(e) = states.delete_many(query.as_mut_slice()) {
+                    return push_error_task!(e);
+                }
+                self.real_delete_states = false;
+            }
         }
         Task::none()
     }
@@ -159,6 +181,14 @@ impl NavigatedPage<RepetitionSettingsMessage> for RepetitionSettingsState {
                 .height(Fill),
                 row![
                     button("Сохранить").style(jl_button).on_press(Save),
+                    horizontal(),
+                    button(if self.real_delete_states {
+                        "Вы уверены?"
+                    } else {
+                        "Удалить прогресс?"
+                    })
+                    .style(danger)
+                    .on_press(DeleteStates),
                     button(if self.real_delete {
                         "Вы уверены?"
                     } else {
@@ -166,7 +196,6 @@ impl NavigatedPage<RepetitionSettingsMessage> for RepetitionSettingsState {
                     })
                     .style(danger)
                     .on_press(DeleteSet),
-                    space().width(Fill),
                 ]
                 .spacing(DEFAULT_SPACING),
             ]
@@ -222,5 +251,6 @@ pub enum RepetitionSettingsMessage {
     SetFilter(String),
     TryFilter,
     DeleteSet,
+    DeleteStates,
     RevertDeleteSet,
 }

src/pages/repetitions.rs

@@ -33,7 +33,7 @@ use std::sync::Arc;
 #[derive(Clone)]
 pub struct RepetitionsState {
     selected_deck_handle: Option<EntityHandle<DeckSettings>>,
-    decks: BTreeMap<EntityHandle<DeckSettings>, DeckViewData>,
+    decks: BTreeMap<EntityHandle<DeckSettings>, DeckRunData>,
     state: AppState,
 }
 
@@ -63,7 +63,7 @@ impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
             }
 
             if let Ok(repetition_state) =
-                RepetitionState::new(selected_set.general_settings.clone(), self.state.clone())
+                RepetitionState::new(selected_set.clone(), self.state.clone())
             {
                 return Some(Repetition(repetition_state));
             }
@@ -111,7 +111,7 @@ impl NavigatedPage<RepetitionsMessage> for RepetitionsState {
                 let handle = self.state.decks.write().create(general.clone());
                 self.decks.insert(
                     handle,
-                    DeckViewData {
+                    DeckRunData {
                         settings_handle: handle,
                         general_settings: general,
                         existing_words_indices: Default::default(),
@@ -258,7 +258,7 @@ impl RepetitionsState {
 
     fn get_decks_from_state(
         state: &AppState,
-    ) -> BTreeMap<EntityHandle<DeckSettings>, DeckViewData> {
+    ) -> BTreeMap<EntityHandle<DeckSettings>, DeckRunData> {
         state
             .decks
             .read()
@@ -267,7 +267,7 @@ impl RepetitionsState {
             .map(|(index, deck)| {
                 (
                     EntityHandle::new(deck.id, index, true),
-                    DeckViewData {
+                    DeckRunData {
                         settings_handle: EntityHandle::new(deck.id, index, true),
                         general_settings: deck.clone(),
                         existing_words_indices: Default::default(),
@@ -284,7 +284,7 @@ impl RepetitionsState {
 }
 
 impl RepetitionsState {
-    fn launch_delete_button(&self, deck: &DeckViewData) -> Element<'_, RepetitionsMessage> {
+    fn launch_delete_button(&self, deck: &DeckRunData) -> Element<'_, RepetitionsMessage> {
         if deck.id.is_valid() {
             if deck.append_mode == AppendMode::Manual && deck.existing_words_indices.is_empty() {
                 return text!("Добавьте карточки или измените фильтр").into();
@@ -468,7 +468,7 @@ impl RepetitionsState {
         })
         .into()
     }
-    fn word_append_panel(&self, deck: &DeckViewData) -> Element<'_, RepetitionsMessage> {
+    fn word_append_panel(&self, deck: &DeckRunData) -> Element<'_, RepetitionsMessage> {
         column![
             text!("Режим добавления карточек"),
             row![
@@ -491,7 +491,7 @@ impl RepetitionsState {
         .spacing(HALF_SPACING)
         .into()
     }
-    fn adder_panel(&self, deck: &DeckViewData) -> Element<'_, RepetitionsMessage> {
+    fn adder_panel(&self, deck: &DeckRunData) -> Element<'_, RepetitionsMessage> {
         match deck.append_mode {
             AppendMode::Full => space().into(),
             AppendMode::Manual => row![
@@ -511,7 +511,7 @@ impl RepetitionsState {
         let available = selected_deck.available_words_indices.len();
         text!("{} слова добавлено из {}", now, available).into()
     }
-    fn count_view(&self, deck: &DeckViewData) -> Element<'_, RepetitionsMessage> {
+    fn count_view(&self, deck: &DeckRunData) -> Element<'_, RepetitionsMessage> {
         if let Some(count) = deck.count {
             return text!("Количество слов: {}", count).into();
         }
@@ -547,7 +547,7 @@ impl RepetitionsState {
 }
 
 impl RepetitionsState {
-    fn append_all_words(state: &mut AppState, deck: &DeckViewData) -> MaybeError {
+    fn append_all_words(state: &mut AppState, deck: &DeckRunData) -> MaybeError {
         let existing = &deck.existing_words_indices;
         let mut created_set = HashSet::with_capacity(existing.len());
         existing.iter().for_each(|c| {
@@ -593,10 +593,10 @@ impl RepetitionsState {
         }
     }
 
-    fn selected_deck(&self) -> Option<&DeckViewData> {
+    fn selected_deck(&self) -> Option<&DeckRunData> {
         self.decks.get(&self.selected_deck_handle?)
     }
-    fn selected_deck_mut(&mut self) -> Option<&mut DeckViewData> {
+    fn selected_deck_mut(&mut self) -> Option<&mut DeckRunData> {
         self.decks.get_mut(&self.selected_deck_handle?)
     }
 
@@ -616,6 +616,7 @@ impl RepetitionsState {
         let total = DeckData::list(&deck, &self.state);
         deck.existing_words_indices = added;
         deck.available_words_indices = total;
+        deck.indices_ready = true;
         self.decks.insert(self.selected_deck_handle.unwrap(), deck);
     }
 }
@@ -641,18 +642,18 @@ pub enum RepetitionsMessage {
 }
 
 #[derive(Clone)]
-struct DeckViewData {
-    settings_handle: EntityHandle<DeckSettings>,
-    general_settings: DeckSettings,
+pub struct DeckRunData {
+    pub settings_handle: EntityHandle<DeckSettings>,
+    pub general_settings: DeckSettings,
     existing_words_indices: Vec<EntityHandle<WordData>>,
     available_words_indices: Vec<EntityHandle<WordData>>,
     indices_ready: bool,
-    append_mode: AppendMode,
+    pub append_mode: AppendMode,
     count: Option<usize>,
-    open_mode: OrderMode,
+    pub open_mode: OrderMode,
 }
 
-impl Deref for DeckViewData {
+impl Deref for DeckRunData {
     type Target = DeckSettings;
 
     fn deref(&self) -> &Self::Target {

src/pages/sync.rs

@@ -273,7 +273,18 @@ impl SyncState {
             .unwrap_or_else(|e| {
                 error!("Ошибка при checkpoint WAL: {e}");
             });
-
+        connection
+            .execute("VACUUM;", [])
+            .unwrap_or_else(|e| {
+                error!("Ошибка при checkpoint WAL: {e}");
+                0
+            });
+        connection
+            .execute("PRAGMA optimize;", [])
+            .unwrap_or_else(|e| {
+                error!("Ошибка при checkpoint WAL: {e}");
+                0
+            });
         connection.finish();
     }
 }