Fix reinsert bug

Cargo.toml

@@ -3,7 +3,7 @@ members = ["codegen", "examples", "performance_measurement", "performance_measur
 
 [package]
 name = "worktable"
-version = "0.6.14"
+version = "0.7.0"
 edition = "2024"
 authors = ["Handy-caT"]
 license = "MIT"
@@ -16,7 +16,7 @@ perf_measurements = ["dep:performance_measurement", "dep:performance_measurement
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-worktable_codegen = { path = "codegen", version = "0.6.14" }
+worktable_codegen = { path = "codegen", version = "0.7.0" }
 
 eyre = "0.6.12"
 derive_more = { version = "1.0.0", features = ["from", "error", "display", "into"] }

codegen/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "worktable_codegen"
-version = "0.6.14"
+version = "0.7.0"
 edition = "2024"
 license = "MIT"
 description = "WorkTable codegeneration crate"

codegen/src/worktable/generator/index/cdc.rs

@@ -93,13 +93,23 @@ impl Generator {
             .iter()
             .map(|(i, idx)| {
                 let index_field_name = &idx.name;
-                quote! {
-                    let (_, events) = self.#index_field_name.insert_cdc(row_new.#i.clone(), link_new);
-                    let mut #index_field_name: Vec<_> = events.into_iter().map(|ev| ev.into()).collect();
-                    if row_new.#i != row_old.#i {
+                let remove = if idx.is_unique {
+                    quote! {
+                        if row_new.#i != row_old.#i {
+                            let (_, events) = TableIndexCdc::remove_cdc(&self.#index_field_name, row_old.#i.clone(), link_old);
+                            #index_field_name.extend(events.into_iter().map(|ev| ev.into()).collect::<Vec<_>>());
+                        }
+                    }
+                } else {
+                    quote! {
                         let (_, events) = TableIndexCdc::remove_cdc(&self.#index_field_name, row_old.#i.clone(), link_old);
                         #index_field_name.extend(events.into_iter().map(|ev| ev.into()).collect::<Vec<_>>());
                     }
+                };
+                quote! {
+                    let (_, events) = self.#index_field_name.insert_cdc(row_new.#i.clone(), link_new);
+                    let mut #index_field_name: Vec<_> = events.into_iter().map(|ev| ev.into()).collect();
+                    #remove
                 }
             })
             .collect::<Vec<_>>();

codegen/src/worktable/generator/index/mod.rs

@@ -158,10 +158,16 @@ impl Generator {
             }
         } else {
             quote! {
-                #[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Ord, Hash, Eq)]
+                #[derive(Debug, Clone, Copy, MoreDisplay, PartialEq, PartialOrd, Ord, Hash, Eq)]
                 pub enum #avt_type_ident {
                     #(#indexes)*
                 }
+
+                impl AvailableIndex for #avt_type_ident {
+                    fn to_string(&self) -> String {
+                        ToString::to_string(&self)
+                    }
+                }
             }
         }
     }

codegen/src/worktable/generator/index/usual.rs

@@ -115,16 +115,25 @@ impl Generator {
                         row.#i
                     }
                 };
+                let remove = if idx.is_unique {
+                    quote! {
+                        if val_new != val_old {
+                            TableIndex::remove(&self.#index_field_name, val_old, link_old);
+                        }
+                    }
+                } else {
+                    quote! {
+                        TableIndex::remove(&self.#index_field_name, val_old, link_old);
+                    }
+                };
                 quote! {
                     let row = &row_new;
                     let val_new = #row.clone();
                     self.#index_field_name.insert(val_new.clone(), link_new);
 
                     let row = &row_old;
                     let val_old = #row.clone();
-                    if val_new != val_old {
-                        TableIndex::remove(&self.#index_field_name, val_old, link_old);
-                    }
+                    #remove
                 }
             })
             .collect::<Vec<_>>();

examples/Cargo.toml

@@ -3,28 +3,4 @@ name = "wt-examples"
 version = "0.1.0"
 edition = "2021"
 
-[dependencies]
-eyre = "0.6.12"
-worktable = { path = "..", version = "0.6.8" }
-#worktable = { path = "..", version = "0.5.3", features = ["perf_measurements"] }
-rkyv = { version = "0.8.9", features = ["uuid-1"] }
-#lockfree = "0.5.1"
-#derive_more = { version = "1.0.0", features = ["full"] }
-#eyre = "0.6.12"
-#futures = "0.3.30"
-#async-std = "1.10"
-#either = "1.15.0"
-#ordered-float = "5.0.0"
-#indexset = { version = "0.12.0", features = ["concurrent", "cdc", "multimap"] }
-#tokio = { version = "1", features = ["full"] }
-tokio = { version = "1", features = ["full"] }
-rand = "0.8"
-chrono = { version = "0.4", features = ["std"] }
-futures = "0.3.30"
-uuid = { version = "1.10.0", features = ["v4", "v7"] }
-derive_more = { version = "1.0.0", features = [
-    "from",
-    "error",
-    "display",
-    "into",
-] }
+[dependencies]

src/index/available_index.rs

@@ -0,0 +1,9 @@
+pub trait AvailableIndex {
+    fn to_string(&self) -> String;
+}
+
+impl AvailableIndex for () {
+    fn to_string(&self) -> String {
+        "".to_string()
+    }
+}

src/index/mod.rs

@@ -1,8 +1,10 @@
+mod available_index;
 mod multipair;
 mod table_index;
 mod table_secondary_index;
 mod unsized_node;
 
+pub use available_index::AvailableIndex;
 pub use indexset::concurrent::map::BTreeMap as IndexMap;
 pub use indexset::concurrent::multimap::BTreeMultiMap as IndexMultiMap;
 pub use multipair::MultiPairRecreate;

src/index/table_secondary_index/mod.rs

@@ -2,12 +2,11 @@ mod cdc;
 mod index_events;
 mod info;
 
-use std::collections::HashMap;
-
 use data_bucket::Link;
+use std::collections::HashMap;
 
-use crate::Difference;
 use crate::WorkTableError;
+use crate::{AvailableIndex, Difference};
 
 pub use cdc::TableSecondaryIndexCdc;
 pub use index_events::TableSecondaryIndexEventsOps;
@@ -84,10 +83,16 @@ pub enum IndexError<IndexNameEnum> {
     NotFound,
 }
 
-impl<IndexNameEnum> From<IndexError<IndexNameEnum>> for WorkTableError {
+impl<IndexNameEnum> From<IndexError<IndexNameEnum>> for WorkTableError
+where
+    IndexNameEnum: AvailableIndex,
+{
     fn from(value: IndexError<IndexNameEnum>) -> Self {
         match value {
-            IndexError::AlreadyExists { .. } => WorkTableError::AlreadyExists,
+            IndexError::AlreadyExists {
+                at,
+                inserted_already: _,
+            } => WorkTableError::AlreadyExists(at.to_string()),
             IndexError::NotFound => WorkTableError::NotFound,
         }
     }

src/lib.rs

@@ -37,8 +37,8 @@ pub mod prelude {
     pub use crate::table::system_info::{IndexInfo, IndexKind, SystemInfo};
     pub use crate::util::{OrderedF32Def, OrderedF64Def};
     pub use crate::{
-        Difference, IndexError, IndexMap, IndexMultiMap, MultiPairRecreate, TableIndex,
-        TableIndexCdc, TableRow, TableSecondaryIndex, TableSecondaryIndexCdc,
+        AvailableIndex, Difference, IndexError, IndexMap, IndexMultiMap, MultiPairRecreate,
+        TableIndex, TableIndexCdc, TableRow, TableSecondaryIndex, TableSecondaryIndexCdc,
         TableSecondaryIndexEventsOps, TableSecondaryIndexInfo, UnsizedNode, WorkTable,
         WorkTableError,
     };
@@ -50,7 +50,7 @@ pub mod prelude {
         VariableSizeMeasurable, VariableSizeMeasure, DATA_VERSION, GENERAL_HEADER_SIZE,
         INNER_PAGE_SIZE, PAGE_SIZE,
     };
-    pub use derive_more::{From, Into};
+    pub use derive_more::{Display as MoreDisplay, From, Into};
     pub use indexset::{
         cdc::change::{ChangeEvent as IndexChangeEvent, Id as IndexChangeEventId},
         core::{multipair::MultiPair as IndexMultiPair, pair::Pair as IndexPair},

src/table/mod.rs

@@ -10,7 +10,8 @@ use crate::persistence::{InsertOperation, Operation};
 use crate::prelude::{OperationId, PrimaryKeyGeneratorState};
 use crate::primary_key::{PrimaryKeyGenerator, TablePrimaryKey};
 use crate::{
-    in_memory, IndexError, IndexMap, TableRow, TableSecondaryIndex, TableSecondaryIndexCdc,
+    in_memory, AvailableIndex, IndexError, IndexMap, TableRow, TableSecondaryIndex,
+    TableSecondaryIndexCdc,
 };
 use data_bucket::{Link, INNER_PAGE_SIZE};
 use derive_more::{Display, Error, From};
@@ -175,6 +176,7 @@ where
         <<Row as StorableRow>::WrappedRow as Archive>::Archived: GhostWrapper,
         PrimaryKey: Clone,
         AvailableTypes: 'static,
+        AvailableIndexes: AvailableIndex,
         SecondaryIndexes: TableSecondaryIndex<Row, AvailableTypes, AvailableIndexes>,
         LockType: 'static,
     {
@@ -186,20 +188,20 @@ where
         if let Some(existed_link) = self.pk_map.insert(pk.clone(), link) {
             self.pk_map.insert(pk.clone(), existed_link);
             self.data.delete(link).map_err(WorkTableError::PagesError)?;
-            return Err(WorkTableError::AlreadyExists);
+            return Err(WorkTableError::AlreadyExists("Primary".to_string()));
         };
         if let Err(e) = self.indexes.save_row(row.clone(), link) {
             return match e {
                 IndexError::AlreadyExists {
-                    at: _,
+                    at,
                     inserted_already,
                 } => {
                     self.data.delete(link).map_err(WorkTableError::PagesError)?;
                     self.pk_map.remove(&pk);
                     self.indexes
                         .delete_from_indexes(row, link, inserted_already)?;
 
-                    Err(WorkTableError::AlreadyExists)
+                    Err(WorkTableError::AlreadyExists(at.to_string()))
                 }
                 IndexError::NotFound => Err(WorkTableError::NotFound),
             };
@@ -240,6 +242,7 @@ where
             + TableSecondaryIndexCdc<Row, AvailableTypes, SecondaryEvents, AvailableIndexes>,
         PkGen: PrimaryKeyGeneratorState,
         AvailableIndexes: Debug,
+        AvailableIndexes: AvailableIndex,
     {
         let pk = row.get_primary_key().clone();
         let (link, _) = self
@@ -250,21 +253,21 @@ where
         if let Some(existed_link) = exists {
             self.pk_map.insert(pk.clone(), existed_link);
             self.data.delete(link).map_err(WorkTableError::PagesError)?;
-            return Err(WorkTableError::AlreadyExists);
+            return Err(WorkTableError::AlreadyExists("Primary".to_string()));
         }
         let indexes_res = self.indexes.save_row_cdc(row.clone(), link);
         if let Err(e) = indexes_res {
             return match e {
                 IndexError::AlreadyExists {
-                    at: _,
+                    at,
                     inserted_already,
                 } => {
                     self.data.delete(link).map_err(WorkTableError::PagesError)?;
                     self.pk_map.remove(&pk);
                     self.indexes
                         .delete_from_indexes(row, link, inserted_already)?;
 
-                    Err(WorkTableError::AlreadyExists)
+                    Err(WorkTableError::AlreadyExists(at.to_string()))
                 }
                 IndexError::NotFound => Err(WorkTableError::NotFound),
             };
@@ -417,7 +420,8 @@ where
 #[derive(Debug, Display, Error, From)]
 pub enum WorkTableError {
     NotFound,
-    AlreadyExists,
+    #[display("Value already exists for `{}` index", _0)]
+    AlreadyExists(#[error(not(source))] String),
     SerializeError,
     SecondaryIndexError,
     PagesError(in_memory::PagesExecutionError),