dictsqlite 2.1.1__tar.gz → 2.1.2__tar.gz

{dictsqlite-2.1.1 → dictsqlite-2.1.2}/Cargo.lock

@@ -412,7 +412,7 @@ dependencies = [
 
 [[package]]
 name = "dictsqlite"
-version = "2.1.1"
+version = "2.1.2"
 dependencies = [
  "aes-gcm",
  "ahash",

{dictsqlite-2.1.1 → dictsqlite-2.1.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "dictsqlite"
-version = "2.1.1"
+version = "2.1.2"
 edition = "2021"
 authors = ["Disnana <support@disnana.com>"]
 description = "High-performance DictSQLite v2 with I/O optimizations (300x async, 43x sync speedup) - Buffered writes and batch operations"

{dictsqlite-2.1.1 → dictsqlite-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dictsqlite
-Version: 2.1.1
+Version: 2.1.2
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Development Status :: 4 - Beta
 Classifier: Operating System :: OS Independent

{dictsqlite-2.1.1 → dictsqlite-2.1.2}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "maturin"
 # PEP 621 project metadata required by maturin >= 0.14
 [project]
 name = "dictsqlite"
-version = "2.1.1"
+version = "2.1.2"
 description = "High-performance DictSQLite v2 with I/O optimizations"
 readme = "Pypi.md"
 requires-python = ">=3.9"

{dictsqlite-2.1.1 → dictsqlite-2.1.2}/src/async_ops.rs

@@ -1,11 +1,12 @@
 // v6.0: PyO3 0.27 API完全移行
 
 use dashmap::DashMap;
+use parking_lot::Mutex;
 use pyo3::prelude::*;
 use pyo3::types::{PyBytes, PyDict};
 use rayon::prelude::*;
 use std::collections::HashMap;
-use std::sync::{Arc, Mutex, OnceLock};
+use std::sync::{Arc, OnceLock};
 use tokio::runtime::Runtime;
 
 use crate::{
@@ -162,7 +163,7 @@ impl AsyncDictSQLite {
         if self.config.persist_mode == PersistMode::WriteThrough {
             // Add to write buffer
             {
-                let mut buffer = self.write_buffer.lock().unwrap();
+                let mut buffer = self.write_buffer.lock();
                 buffer.insert(key, value);
             }
 
@@ -177,7 +178,7 @@ impl AsyncDictSQLite {
     /// Flush write buffer to storage (v4.2 optimization)
     /// Batches multiple writes into a single transaction
     fn flush_write_buffer(&self) -> PyResult<()> {
-        let mut buffer = self.write_buffer.lock().unwrap();
+        let mut buffer = self.write_buffer.lock();
 
         if buffer.is_empty() {
             return Ok(());
@@ -373,7 +374,7 @@ impl AsyncDictSQLite {
         if config.persist_mode == PersistMode::WriteThrough {
             // Add to write buffer
             let should_flush = {
-                let mut buffer = write_buffer.lock().unwrap();
+                let mut buffer = write_buffer.lock();
                 buffer.insert(key, value);
                 buffer.len() >= buffer_size
             };
@@ -382,7 +383,7 @@ impl AsyncDictSQLite {
             if should_flush {
                 runtime
                     .spawn_blocking(move || {
-                        let mut buffer = write_buffer.lock().unwrap();
+                        let mut buffer = write_buffer.lock();
                         if buffer.is_empty() {
                             return Ok(());
                         }
@@ -475,7 +476,7 @@ impl AsyncDictSQLite {
         if config.persist_mode == PersistMode::WriteThrough {
             // Add to write buffer
             let should_flush = {
-                let mut buffer = write_buffer.lock().unwrap();
+                let mut buffer = write_buffer.lock();
                 for (key, value) in items {
                     buffer.insert(key, value);
                 }
@@ -488,7 +489,7 @@ impl AsyncDictSQLite {
             if should_flush {
                 runtime
                     .spawn_blocking(move || {
-                        let mut buffer = write_buffer.lock().unwrap();
+                        let mut buffer = write_buffer.lock();
                         if buffer.is_empty() {
                             return Ok(());
                         }
@@ -587,7 +588,7 @@ impl AsyncDictSQLite {
         runtime
             .spawn_blocking(move || {
                 // First, flush any pending writes in the buffer
-                let mut buffer = write_buffer.lock().unwrap();
+                let mut buffer = write_buffer.lock();
                 if !buffer.is_empty() {
                     if let Some(ref storage_engine) = *storage {
                         for (k, v) in buffer.drain() {
@@ -771,7 +772,7 @@ impl AsyncDictSQLite {
 
         // Remove from write buffer
         if self.config.persist_mode == PersistMode::WriteThrough {
-            let mut buffer = self.write_buffer.lock().unwrap();
+            let mut buffer = self.write_buffer.lock();
             buffer.remove(&full_key);
         }
 

{dictsqlite-2.1.1 → dictsqlite-2.1.2}/src/lib.rs

@@ -49,13 +49,14 @@
 
 use dashmap::DashMap;
 use lru::LruCache;
+use parking_lot::Mutex;
 use pyo3::prelude::*;
 use pyo3::types::{PyAny, PyBytes, PyDict};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::num::NonZeroUsize;
 use std::str::FromStr;
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 
 // v4.2.4 パフォーマンス最適化定数
 /// 小容量キャパシティの閾値 (この値以下では厳密なキャパシティ管理)
@@ -698,8 +699,9 @@ pub struct DictSQLiteV4 {
     /// ストレージエンジン: warm/cold tierの管理
     ///
     /// Memory以外の永続化モードで使用。
-    /// SQLiteへの読み書きを担当。
-    storage: Arc<Mutex<Option<StorageEngine>>>,
+    /// StorageEngineは内部でr2d2コネクションプール + DashMapを使用するため
+    /// スレッドセーフであり、外部のMutexは不要。
+    storage: Option<Arc<StorageEngine>>,
 
     /// 設定
     config: Config,
@@ -950,13 +952,14 @@ impl DictSQLiteV4 {
         )));
 
         // 純粋なメモリモードでない場合のみストレージを作成
+        // StorageEngineは内部でスレッドセーフなので Arc だけでラップする
         let storage = if config.persist_mode == PersistMode::Memory {
-            Arc::new(Mutex::new(None))
+            None
         } else {
-            Arc::new(Mutex::new(Some(
+            Some(Arc::new(
                 StorageEngine::new(&db_path, &config)
                     .map_err(|e| PyErr::new::<pyo3::exceptions::PyIOError, _>(e.to_string()))?,
-            )))
+            ))
         };
 
         // パスワードが提供された場合、暗号化エンジンを初期化
@@ -1021,8 +1024,8 @@ impl DictSQLiteV4 {
     /// - 復号化に失敗した場合: ValueError
     #[pyo3(signature = (key, default=None))]
     fn get(&self, key: String, default: Option<Vec<u8>>, py: Python) -> PyResult<Py<PyAny>> {
-        // v4.2.4最適化: LRU追跡は必要な場合のみ実行（Memory/Lazyモードではスキップ）
-        // WriteThroughモードまたはキャパシティ超過時のみLRU追跡
+        // v7.1最適化: LRU追跡はキャパシティ超過時のみ実行（エビクション判定が必要な場合のみ）
+        // WriteThroughモードの特別扱いを廃止し、全モードで同一の閾値を使用
         let current_size = self.hot_tier.len();
         let tracking_threshold = if self.config.hot_tier_capacity <= SMALL_CAPACITY_THRESHOLD {
             // 小容量: 常に追跡（テスト互換性）
@@ -1031,11 +1034,10 @@ impl DictSQLiteV4 {
             // 大容量: LRU_TRACKING_THRESHOLD_PERCENT%から追跡（パフォーマンス優先）
             (self.config.hot_tier_capacity * LRU_TRACKING_THRESHOLD_PERCENT) / 100
         };
-        let needs_lru = self.config.persist_mode == PersistMode::WriteThrough
-            || current_size >= tracking_threshold;
+        let needs_lru = current_size >= tracking_threshold;
 
         if needs_lru {
-            self.access_tracker.lock().unwrap().put(key.clone(), ());
+            self.access_tracker.lock().put(key.clone(), ());
         }
 
         // Hot tierを最初に試行（ロックフリー読み取り）
@@ -1066,8 +1068,7 @@ impl DictSQLiteV4 {
         }
 
         // 他のモードではストレージ（Cold tier）も検索
-        let storage_guard = self.storage.lock().unwrap();
-        if let Some(ref storage) = *storage_guard {
+        if let Some(ref storage) = self.storage {
             if let Ok(Some(value)) = storage.get(&key) {
                 // 暗号化されているがパスワードがない場合のチェック
                 if self.crypto.is_none() && crate::crypto::CryptoEngine::is_encrypted(&value) {
@@ -1087,7 +1088,6 @@ impl DictSQLiteV4 {
 
                 // Hot tierにプロモート（暗号化状態で保存）
                 // これにより次回アクセス時の速度が向上
-                drop(storage_guard);
                 self.hot_tier.insert(key, value);
                 return Ok(PyBytes::new(py, &data).into());
             }
@@ -1154,9 +1154,8 @@ impl DictSQLiteV4 {
             (is_new, None)
         };
 
-        // v4.2.4最適化: LRUアクセス追跡の条件付き更新（パフォーマンス向上）
-        // Memory/Lazyモードでは大容量を前提としているため、LRU追跡を最小化
-        // WriteThroughモードまたはキャパシティ超過時のみLRU追跡を有効化
+        // v7.1最適化: LRUアクセス追跡はキャパシティ超過時のみ実行
+        // WriteThroughモードの特別扱いを廃止し、全モードで同一の閾値を使用
         let current_size = self.hot_tier.len();
         let tracking_threshold = if self.config.hot_tier_capacity <= SMALL_CAPACITY_THRESHOLD {
             // 小容量: 常に追跡（テスト互換性）
@@ -1165,17 +1164,16 @@ impl DictSQLiteV4 {
             // 大容量: LRU_TRACKING_THRESHOLD_PERCENT%から追跡（パフォーマンス優先）
             (self.config.hot_tier_capacity * LRU_TRACKING_THRESHOLD_PERCENT) / 100
         };
-        let needs_lru = self.config.persist_mode == PersistMode::WriteThrough
-            || current_size >= tracking_threshold;
+        let needs_lru = current_size >= tracking_threshold;
 
         if is_new_key && needs_lru {
-            self.access_tracker.lock().unwrap().put(key.clone(), ());
+            self.access_tracker.lock().put(key.clone(), ());
         }
 
         // v4.2.2最適化: WriteThroughモードでは書き込みバッファを使用
         if self.config.persist_mode == PersistMode::WriteThrough {
             let should_flush = {
-                let mut buffer = self.write_buffer.lock().unwrap();
+                let mut buffer = self.write_buffer.lock();
                 buffer.push((key.clone(), data_for_buffer.unwrap()));
                 // バッファサイズに達したらフラッシュ
                 // buffer_size=1の場合は即時フラッシュ
@@ -1219,7 +1217,7 @@ impl DictSQLiteV4 {
     /// # エラー
     /// - ストレージ書き込みに失敗した場合: IOError
     fn evict_to_warm_tier(&self) -> PyResult<()> {
-        let mut tracker = self.access_tracker.lock().unwrap();
+        let mut tracker = self.access_tracker.lock();
 
         // v4.2.4最適化: 一度にBATCH_EVICTION_PERCENT%のエントリをエビクション（バッチ処理）
         let eviction_count = std::cmp::max(
@@ -1245,8 +1243,7 @@ impl DictSQLiteV4 {
 
         // Memoryモードでない場合はストレージに一括書き込み
         if self.config.persist_mode != PersistMode::Memory && !evicted_items.is_empty() {
-            let mut storage_guard = self.storage.lock().unwrap();
-            if let Some(ref mut storage) = *storage_guard {
+            if let Some(ref storage) = self.storage {
                 // bulk_insertで一括書き込み（単一トランザクション）
                 storage
                     .bulk_insert(&evicted_items)
@@ -1269,7 +1266,7 @@ impl DictSQLiteV4 {
     /// - `Ok(())`: フラッシュ成功
     /// - `Err(PyErr)`: ストレージ書き込みエラー
     fn flush_write_buffer(&self) -> PyResult<()> {
-        let mut buffer = self.write_buffer.lock().unwrap();
+        let mut buffer = self.write_buffer.lock();
 
         // バッファが空の場合は何もしない
         if buffer.is_empty() {
@@ -1283,8 +1280,7 @@ impl DictSQLiteV4 {
         drop(buffer);
 
         // ストレージハンドルを取得してバルクインサート
-        let mut storage_guard = self.storage.lock().unwrap();
-        if let Some(ref mut storage) = *storage_guard {
+        if let Some(ref storage) = self.storage {
             // bulk_insert()を使用して単一トランザクションで高速書き込み
             storage
                 .bulk_insert(&items)
@@ -1331,8 +1327,7 @@ impl DictSQLiteV4 {
                 .collect();
 
             // バルクインサートで一括永続化（単一トランザクション）
-            let mut storage_guard = self.storage.lock().unwrap();
-            if let Some(ref mut storage) = *storage_guard {
+            if let Some(ref storage) = self.storage {
                 storage
                     .bulk_insert(&items)
                     .map_err(|e| PyErr::new::<pyo3::exceptions::PyIOError, _>(e.to_string()))?;
@@ -1352,21 +1347,20 @@ impl DictSQLiteV4 {
         }
 
         // Track that we're removing this
-        self.access_tracker.lock().unwrap().pop(&key);
+        self.access_tracker.lock().pop(&key);
 
         // Remove from hot tier
         self.hot_tier.remove(&key);
 
         // Remove from write buffer (v4.2)
         if self.config.persist_mode == PersistMode::WriteThrough {
-            let mut buffer = self.write_buffer.lock().unwrap();
+            let mut buffer = self.write_buffer.lock();
             buffer.retain(|(k, _)| k != &key);
         }
 
         // Also remove from storage
         if self.config.persist_mode != PersistMode::Memory {
-            let mut storage_guard = self.storage.lock().unwrap();
-            if let Some(ref mut storage) = *storage_guard {
+            if let Some(ref storage) = self.storage {
                 let _ = storage.delete(&key);
             }
         }
@@ -1424,8 +1418,7 @@ impl DictSQLiteV4 {
         }
 
         // 3. ストレージからキャッシュミスを取得
-        let storage_guard = self.storage.lock().unwrap();
-        if let Some(ref storage) = *storage_guard {
+        if let Some(ref storage) = self.storage {
             for key in cache_misses {
                 if let Ok(Some(value)) = storage.get(&key) {
                     let data = if let Some(ref crypto) = self.crypto {
@@ -1463,7 +1456,7 @@ impl DictSQLiteV4 {
 
             // WriteThroughモードではバッファに追加
             if self.config.persist_mode == PersistMode::WriteThrough {
-                let mut buffer = self.write_buffer.lock().unwrap();
+                let mut buffer = self.write_buffer.lock();
                 buffer.push((key, data));
             }
         }
@@ -1489,8 +1482,7 @@ impl DictSQLiteV4 {
 
         // Also get keys from storage if not in memory-only mode
         if self.config.persist_mode != PersistMode::Memory {
-            let storage_guard = self.storage.lock().unwrap();
-            if let Some(ref storage) = *storage_guard {
+            if let Some(ref storage) = self.storage {
                 if let Ok(storage_keys) = storage.keys() {
                     all_keys.extend(storage_keys);
                 }
@@ -1508,8 +1500,7 @@ impl DictSQLiteV4 {
         let mut all_items: HashMap<String, Vec<u8>> = HashMap::new();
 
         if self.config.persist_mode != PersistMode::Memory {
-            let storage_guard = self.storage.lock().unwrap();
-            if let Some(ref storage) = *storage_guard {
+            if let Some(ref storage) = self.storage {
                 if let Ok(keys) = storage.keys() {
                     for key in keys {
                         if let Ok(Some(value)) = storage.get(&key) {
@@ -1548,8 +1539,7 @@ impl DictSQLiteV4 {
         let mut all_items: HashMap<String, Vec<u8>> = HashMap::new();
 
         if self.config.persist_mode != PersistMode::Memory {
-            let storage_guard = self.storage.lock().unwrap();
-            if let Some(ref storage) = *storage_guard {
+            if let Some(ref storage) = self.storage {
                 if let Ok(keys) = storage.keys() {
                     for key in keys {
                         if let Ok(Some(value)) = storage.get(&key) {
@@ -1589,7 +1579,7 @@ impl DictSQLiteV4 {
     #[pyo3(signature = (key, default=None))]
     fn pop(&self, key: String, default: Option<Vec<u8>>, py: Python) -> PyResult<Py<PyAny>> {
         // Track that we're removing this
-        self.access_tracker.lock().unwrap().pop(&key);
+        self.access_tracker.lock().pop(&key);
 
         if let Some((_, value)) = self.hot_tier.remove(&key) {
             let data = if let Some(ref crypto) = self.crypto {
@@ -1604,8 +1594,7 @@ impl DictSQLiteV4 {
 
         // Also try to remove from storage if it exists there
         if self.config.persist_mode != PersistMode::Memory {
-            let mut storage_guard = self.storage.lock().unwrap();
-            if let Some(ref mut storage) = *storage_guard {
+            if let Some(ref storage) = self.storage {
                 if let Ok(Some(value)) = storage.get(&key) {
                     // Delete from storage
                     let _ = storage.delete(&key);
@@ -1642,8 +1631,7 @@ impl DictSQLiteV4 {
 
         // Not in hot tier, check storage
         if self.config.persist_mode != PersistMode::Memory {
-            let storage_guard = self.storage.lock().unwrap();
-            if let Some(ref storage) = *storage_guard {
+            if let Some(ref storage) = self.storage {
                 if let Ok(Some(value)) = storage.get(&key) {
                     let data = if let Some(ref crypto) = self.crypto {
                         crypto.decrypt(&value).map_err(|e| {
@@ -1652,7 +1640,6 @@ impl DictSQLiteV4 {
                     } else {
                         value.clone()
                     };
-                    drop(storage_guard);
                     // Promote to hot tier
                     self.hot_tier.insert(key, value);
                     return Ok(PyBytes::new(py, &data).into());
@@ -1702,8 +1689,7 @@ impl DictSQLiteV4 {
 
         // Also get keys from storage if not in memory-only mode
         if self.config.persist_mode != PersistMode::Memory {
-            let storage_guard = self.storage.lock().unwrap();
-            if let Some(ref storage) = *storage_guard {
+            if let Some(ref storage) = self.storage {
                 if let Ok(storage_keys) = storage.keys() {
                     for key in storage_keys {
                         // Apply same filtering logic
@@ -1741,8 +1727,7 @@ impl DictSQLiteV4 {
 
         // Then check storage
         if self.config.persist_mode != PersistMode::Memory {
-            let storage_guard = self.storage.lock().unwrap();
-            if let Some(ref storage) = *storage_guard {
+            if let Some(ref storage) = self.storage {
                 if let Ok(Some(_)) = storage.get(&full_key) {
                     return Ok(true);
                 }
@@ -1758,12 +1743,11 @@ impl DictSQLiteV4 {
         self.hot_tier.clear();
 
         // Clear write buffer to prevent pending writes from re-populating the database
-        self.write_buffer.lock().unwrap().clear();
+        self.write_buffer.lock().clear();
 
         // Clear storage if not in memory-only mode
         if self.config.persist_mode != PersistMode::Memory {
-            let mut storage_guard = self.storage.lock().unwrap();
-            if let Some(ref mut storage) = *storage_guard {
+            if let Some(ref storage) = self.storage {
                 storage.clear().map_err(|e| {
                     PyErr::new::<pyo3::exceptions::PyRuntimeError, _>(format!(
                         "Failed to clear storage: {}",
@@ -1986,8 +1970,7 @@ impl DictSQLiteV4 {
                     tables.insert("main".to_string());
                     Ok(tables.into_iter().collect())
                 } else {
-                    let storage_guard = self.storage.lock().unwrap();
-                    if let Some(ref storage) = *storage_guard {
+                    if let Some(ref storage) = self.storage {
                         storage.list_tables().map_err(|e| {
                             PyErr::new::<pyo3::exceptions::PyIOError, _>(e.to_string())
                         })
@@ -2042,12 +2025,10 @@ impl TableProxy {
                     }
                 } else {
                     // Check storage
-                    let storage_guard = db.storage.lock().unwrap();
-                    if let Some(ref storage) = *storage_guard {
+                    if let Some(ref storage) = db.storage {
                         match storage.get_with_table(&self.table_name, &key) {
                             Ok(Some(value)) => {
                                 // Promote to hot tier
-                                drop(storage_guard);
                                 db.hot_tier.insert(cache_key, value.clone());
                                 // Decrypt if needed
                                 if let Some(ref crypto) = db.crypto {
@@ -2167,12 +2148,11 @@ impl TableProxy {
                 // Update hot tier
                 db.hot_tier
                     .insert(cache_key.clone(), encrypted_data.clone());
-                db.access_tracker.lock().unwrap().put(cache_key, ());
+                db.access_tracker.lock().put(cache_key, ());
 
                 // Write to storage in WriteThrough mode
                 if db.config.persist_mode == PersistMode::WriteThrough {
-                    let mut storage_guard = db.storage.lock().unwrap();
-                    if let Some(ref mut storage) = *storage_guard {
+                    if let Some(ref storage) = db.storage {
                         storage
                             .set_with_table(&self.table_name, &key, &encrypted_data)
                             .map_err(|e| {
@@ -2199,13 +2179,12 @@ impl TableProxy {
                 let cache_key = format!("{}:{}", self.table_name, key);
 
                 // Remove from hot tier
-                db.access_tracker.lock().unwrap().pop(&cache_key);
+                db.access_tracker.lock().pop(&cache_key);
                 db.hot_tier.remove(&cache_key);
 
                 // Remove from storage
                 if db.config.persist_mode != PersistMode::Memory {
-                    let mut storage_guard = db.storage.lock().unwrap();
-                    if let Some(ref mut storage) = *storage_guard {
+                    if let Some(ref storage) = db.storage {
                         let _ = storage.delete_with_table(&self.table_name, &key);
                     }
                 }
@@ -2234,8 +2213,7 @@ impl TableProxy {
 
                 // Check storage
                 if db.config.persist_mode != PersistMode::Memory {
-                    let storage_guard = db.storage.lock().unwrap();
-                    if let Some(ref storage) = *storage_guard {
+                    if let Some(ref storage) = db.storage {
                         if let Ok(Some(_)) = storage.get_with_table(&self.table_name, &key) {
                             return Ok(true);
                         }
@@ -2282,8 +2260,7 @@ impl TableProxy {
 
                 // Get keys from storage
                 if db.config.persist_mode != PersistMode::Memory {
-                    let storage_guard = db.storage.lock().unwrap();
-                    if let Some(ref storage) = *storage_guard {
+                    if let Some(ref storage) = db.storage {
                         if let Ok(storage_keys) = storage.keys_with_table(&self.table_name) {
                             all_keys.extend(storage_keys);
                         }
@@ -2399,13 +2376,12 @@ impl TableProxy {
 
                 for key in keys_to_remove {
                     db.hot_tier.remove(&key);
-                    db.access_tracker.lock().unwrap().pop(&key);
+                    db.access_tracker.lock().pop(&key);
                 }
 
                 // Clear storage table
                 if db.config.persist_mode != PersistMode::Memory {
-                    let mut storage_guard = db.storage.lock().unwrap();
-                    if let Some(ref mut storage) = *storage_guard {
+                    if let Some(ref storage) = db.storage {
                         storage.clear_table(&self.table_name).map_err(|e| {
                             PyErr::new::<pyo3::exceptions::PyIOError, _>(e.to_string())
                         })?;