Merge pull request #47 from tidesdb/0-9-5

issue #46 extend python library to match c library db.h functionality…

Author: guycipher

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tidesdb"
-version = "0.9.4"
+version = "0.9.5"
 description = "Official Python bindings for TidesDB - A high-performance embedded key-value storage engine"
 readme = "README.md"
 requires-python = ">=3.10"

src/tidesdb/__init__.py

@@ -30,7 +30,7 @@
     COMMIT_HOOK_FUNC,
 )
 
-__version__ = "0.9.1"
+__version__ = "0.9.5"
 __all__ = [
     "TidesDB",
     "Transaction",

src/tidesdb/tidesdb.py

@@ -232,6 +232,7 @@ class _CConfig(Structure):
         ("log_level", c_int),
         ("block_cache_size", c_size_t),
         ("max_open_sstables", c_size_t),
+        ("max_memory_usage", c_size_t),
         ("log_to_file", c_int),
         ("log_truncation_at", c_size_t),
     ]
@@ -444,6 +445,12 @@ class _CCacheStats(Structure):
 _lib.tidesdb_register_comparator.argtypes = [c_void_p, c_char_p, COMPARATOR_FUNC, c_void_p, DESTROY_FUNC]
 _lib.tidesdb_register_comparator.restype = c_int
 
+_lib.tidesdb_get_comparator.argtypes = [c_void_p, c_char_p, POINTER(COMPARATOR_FUNC), POINTER(c_void_p)]
+_lib.tidesdb_get_comparator.restype = c_int
+
+_lib.tidesdb_delete_column_family.argtypes = [c_void_p, c_void_p]
+_lib.tidesdb_delete_column_family.restype = c_int
+
 
 @dataclass
 class Config:
@@ -455,6 +462,7 @@ class Config:
     log_level: LogLevel = LogLevel.LOG_INFO
     block_cache_size: int = 64 * 1024 * 1024
     max_open_sstables: int = 256
+    max_memory_usage: int = 0
     log_to_file: bool = False
     log_truncation_at: int = 24 * 1024 * 1024
 
@@ -1230,6 +1238,7 @@ def __init__(self, config: Config) -> None:
             log_level=int(config.log_level),
             block_cache_size=config.block_cache_size,
             max_open_sstables=config.max_open_sstables,
+            max_memory_usage=config.max_memory_usage,
             log_to_file=1 if config.log_to_file else 0,
             log_truncation_at=config.log_truncation_at,
         )
@@ -1251,6 +1260,7 @@ def open(
         log_level: LogLevel = LogLevel.LOG_INFO,
         block_cache_size: int = 64 * 1024 * 1024,
         max_open_sstables: int = 256,
+        max_memory_usage: int = 0,
         log_to_file: bool = False,
         log_truncation_at: int = 24 * 1024 * 1024,
     ) -> TidesDB:
@@ -1264,6 +1274,7 @@ def open(
             log_level: Logging level
             block_cache_size: Size of block cache in bytes
             max_open_sstables: Maximum number of open SSTables
+            max_memory_usage: Global memory limit in bytes (0 = auto, 50% of system RAM)
             log_to_file: Write logs to file instead of stderr
             log_truncation_at: Log file truncation size in bytes (0 = no truncation)
 
@@ -1277,6 +1288,7 @@ def open(
             log_level=log_level,
             block_cache_size=block_cache_size,
             max_open_sstables=max_open_sstables,
+            max_memory_usage=max_memory_usage,
             log_to_file=log_to_file,
             log_truncation_at=log_truncation_at,
         )
@@ -1599,11 +1611,51 @@ def c_comparator(key1_ptr, key1_size, key2_ptr, key2_size, ctx_ptr):
         self._comparator_refs.append(c_func)
 
         result = _lib.tidesdb_register_comparator(
-            self._db, name.encode("utf-8"), c_func, None, None
+            self._db, name.encode("utf-8"), c_func, c_void_p(None), DESTROY_FUNC()
         )
         if result != TDB_SUCCESS:
             raise TidesDBError.from_code(result, "failed to register comparator")
 
+    def get_comparator(self, name: str) -> bool:
+        """
+        Check if a comparator is registered by name.
+
+        Args:
+            name: Name of the comparator to look up
+
+        Returns:
+            True if the comparator is registered, False otherwise
+        """
+        if self._closed:
+            raise TidesDBError("Database is closed")
+
+        fn = COMPARATOR_FUNC()
+        ctx = c_void_p()
+        result = _lib.tidesdb_get_comparator(
+            self._db, name.encode("utf-8"), ctypes.byref(fn), ctypes.byref(ctx)
+        )
+        return result == TDB_SUCCESS
+
+    def delete_column_family(self, cf: ColumnFamily) -> None:
+        """
+        Delete a column family by pointer (skips name lookup).
+
+        This is faster than drop_column_family() when you already hold a
+        ColumnFamily handle, as it avoids a redundant linear scan by name.
+
+        Args:
+            cf: Column family handle to delete
+
+        Raises:
+            TidesDBError: If deletion fails
+        """
+        if self._closed:
+            raise TidesDBError("Database is closed")
+
+        result = _lib.tidesdb_delete_column_family(self._db, cf._cf)
+        if result != TDB_SUCCESS:
+            raise TidesDBError.from_code(result, "failed to delete column family")
+
     def __enter__(self) -> TidesDB:
         return self
 

tests/test_tidesdb.py

@@ -887,5 +887,85 @@ def crashing_hook(ops, commit_seq):
             assert txn.get(cf, b"crash_key") == b"crash_val"
 
 
+class TestGetComparator:
+    """Tests for get_comparator operations."""
+
+    def test_builtin_comparator_exists(self, db):
+        """Test that built-in comparators are registered."""
+        assert db.get_comparator("memcmp") is True
+        assert db.get_comparator("reverse") is True
+        assert db.get_comparator("lexicographic") is True
+
+    def test_nonexistent_comparator(self, db):
+        """Test that a non-existent comparator returns False."""
+        assert db.get_comparator("nonexistent_comp") is False
+
+    def test_custom_comparator_registered(self, db):
+        """Test that a custom registered comparator is found."""
+        def my_cmp(k1: bytes, k2: bytes) -> int:
+            if k1 < k2:
+                return -1
+            elif k1 > k2:
+                return 1
+            return 0
+
+        db.register_comparator("my_test_cmp", my_cmp)
+        assert db.get_comparator("my_test_cmp") is True
+
+
+class TestDeleteColumnFamily:
+    """Tests for delete_column_family (by pointer) operations."""
+
+    def test_delete_by_pointer(self, db):
+        """Test deleting a column family by pointer."""
+        db.create_column_family("del_cf")
+        cf = db.get_column_family("del_cf")
+        assert cf is not None
+
+        db.delete_column_family(cf)
+
+        with pytest.raises(tidesdb.TidesDBError):
+            db.get_column_family("del_cf")
+
+    def test_delete_with_data(self, db):
+        """Test deleting a column family that contains data."""
+        db.create_column_family("data_cf")
+        cf = db.get_column_family("data_cf")
+
+        with db.begin_txn() as txn:
+            txn.put(cf, b"key1", b"value1")
+            txn.commit()
+
+        db.delete_column_family(cf)
+
+        with pytest.raises(tidesdb.TidesDBError):
+            db.get_column_family("data_cf")
+
+
+class TestMaxMemoryUsage:
+    """Tests for max_memory_usage configuration."""
+
+    def test_config_default(self):
+        """Test that default max_memory_usage is 0."""
+        config = tidesdb.Config(db_path="/tmp/test")
+        assert config.max_memory_usage == 0
+
+    def test_open_with_max_memory_usage(self, temp_db_path):
+        """Test opening a database with max_memory_usage set."""
+        db = tidesdb.TidesDB.open(temp_db_path, max_memory_usage=0)
+        assert db is not None
+        db.close()
+
+    def test_config_with_max_memory_usage(self, temp_db_path):
+        """Test Config with explicit max_memory_usage."""
+        config = tidesdb.Config(
+            db_path=temp_db_path,
+            max_memory_usage=512 * 1024 * 1024,  # 512MB
+        )
+        db = tidesdb.TidesDB(config)
+        assert db is not None
+        db.close()
+
+
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])