minidb-sql 1.3.0__py3-none-any.whl

minidb_sql/errors.py

@@ -0,0 +1,176 @@
+"""Custom exceptions for MiniDB."""
+
+
+class MiniDBError(Exception):
+    """Base exception for all MiniDB errors."""
+
+    pass
+
+
+class TableError(MiniDBError):
+    """Errors related to table operations."""
+
+    pass
+
+
+class TableNotFoundError(TableError):
+    """Raised when a table does not exist."""
+
+    def __init__(self, table_name: str):
+        self.table_name = table_name
+        super().__init__(f"Table '{table_name}' not found")
+
+
+class TableExistsError(TableError):
+    """Raised when a table already exists."""
+
+    def __init__(self, table_name: str):
+        self.table_name = table_name
+        super().__init__(f"Table '{table_name}' already exists")
+
+
+class ColumnError(MiniDBError):
+    """Errors related to column operations."""
+
+    pass
+
+
+class ColumnNotFoundError(ColumnError):
+    """Raised when a column does not exist."""
+
+    def __init__(self, column_name: str, table_name: str | None = None):
+        self.column_name = column_name
+        self.table_name = table_name
+        msg = f"Column '{column_name}' not found"
+        if table_name:
+            msg += f" in table '{table_name}'"
+        super().__init__(msg)
+
+
+class ColumnExistsError(ColumnError):
+    """Raised when a column already exists."""
+
+    def __init__(self, column_name: str, table_name: str):
+        self.column_name = column_name
+        self.table_name = table_name
+        super().__init__(f"Column '{column_name}' already exists in table '{table_name}'")
+
+
+class TypeError_(MiniDBError):
+    """Errors related to type validation."""
+
+    pass
+
+
+class TypeMismatchError(TypeError_):
+    """Raised when a value doesn't match the column type."""
+
+    def __init__(self, column_name: str, expected_type: str, actual_type: str):
+        self.column_name = column_name
+        self.expected_type = expected_type
+        self.actual_type = actual_type
+        super().__init__(f"Type mismatch for column '{column_name}': expected {expected_type}, got {actual_type}")
+
+
+class NullValueError(TypeError_):
+    """Raised when a NULL value is provided for a non-nullable column."""
+
+    def __init__(self, column_name: str):
+        self.column_name = column_name
+        super().__init__(f"NULL value not allowed for column '{column_name}'")
+
+
+class ParseError(MiniDBError):
+    """Errors related to SQL parsing."""
+
+    pass
+
+
+class SyntaxError_(ParseError):
+    """Raised when there's a syntax error in the SQL query."""
+
+    def __init__(self, message: str, position: int | None = None):
+        self.position = position
+        msg = f'Syntax error: {message}'
+        if position is not None:
+            msg += f' at position {position}'
+        super().__init__(msg)
+
+
+class QueryError(MiniDBError):
+    """Errors related to query execution."""
+
+    pass
+
+
+class InvalidQueryError(QueryError):
+    """Raised when a query is invalid."""
+
+    def __init__(self, message: str):
+        super().__init__(f'Invalid query: {message}')
+
+
+class AmbiguousColumnError(QueryError):
+    """Raised when a column reference is ambiguous."""
+
+    def __init__(self, column_name: str):
+        self.column_name = column_name
+        super().__init__(f"Ambiguous column reference: '{column_name}'")
+
+
+class ConstraintError(MiniDBError):
+    """Errors related to constraint violations."""
+
+    pass
+
+
+class PrimaryKeyError(ConstraintError):
+    """Raised when a primary key constraint is violated."""
+
+    def __init__(self, message: str):
+        super().__init__(f'Primary key constraint violation: {message}')
+
+
+class DuplicateKeyError(PrimaryKeyError):
+    """Raised when a duplicate primary key is inserted."""
+
+    def __init__(self, key_value):
+        self.key_value = key_value
+        super().__init__(f'Duplicate primary key value: {key_value}')
+
+
+class PersistenceError(MiniDBError):
+    """Errors related to persistence operations."""
+
+    pass
+
+
+class FileReadError(PersistenceError):
+    """Raised when a file cannot be read."""
+
+    def __init__(self, filepath: str, reason: str | None = None):
+        self.filepath = filepath
+        msg = f'Failed to read file: {filepath}'
+        if reason:
+            msg += f' - {reason}'
+        super().__init__(msg)
+
+
+class FileWriteError(PersistenceError):
+    """Raised when a file cannot be written."""
+
+    def __init__(self, filepath: str, reason: str | None = None):
+        self.filepath = filepath
+        msg = f'Failed to write file: {filepath}'
+        if reason:
+            msg += f' - {reason}'
+        super().__init__(msg)
+
+
+class VersionMismatchError(PersistenceError):
+    """Raised when the persistence file version is incompatible."""
+
+    def __init__(self, version: str, expected: str):
+        self.version = version
+        self.expected = expected
+        super().__init__(f'Incompatible persistence file version: {version} (expected {expected})')

minidb_sql/index.py

@@ -0,0 +1,222 @@
+"""Hash-based index implementation for MiniDB."""
+
+import math
+from bisect import bisect_left, bisect_right
+from dataclasses import dataclass, field
+from typing import Any
+
+from .errors import TypeMismatchError
+
+# NaN is not equal to itself, so it cannot be a dict key as a float.
+_NAN = object()
+
+
+def _index_key(value: Any) -> Any:
+    """Map NaN to one key so a second NaN primary key is a duplicate."""
+    if isinstance(value, float) and math.isnan(value):
+        return _NAN
+    return value
+
+
+@dataclass
+class HashIndex:
+    """
+    Hash-based index for fast equality lookups.
+
+    Maps values to sets of row IDs for O(1) equality lookups.
+    For range queries, maintains a sorted list of keys.
+    """
+
+    column_name: str
+    _index: dict[Any, set[int]] = field(default_factory=dict)
+    _sorted_keys: list[Any] = field(default_factory=list)
+
+    def insert(self, value: Any, row_id: int) -> None:
+        """
+        Add a row ID to the index for a given value.
+
+        Args:
+            value: The indexed value
+            row_id: The row ID to associate with this value
+        """
+        key = _index_key(value)
+        if key not in self._index:
+            self._index[key] = set()
+            # NaN is not ordered. Equality still sees it via _NAN.
+            if key is not _NAN:
+                self._insert_sorted_key(value)
+        self._index[key].add(row_id)
+
+    def _insert_sorted_key(self, value: Any) -> None:
+        """Insert a key into the sorted keys list."""
+        pos = bisect_left(self._sorted_keys, value)
+        if pos == len(self._sorted_keys) or self._sorted_keys[pos] != value:
+            self._sorted_keys.insert(pos, value)
+
+    def delete(self, value: Any, row_id: int) -> None:
+        """
+        Remove a row ID from the index for a given value.
+
+        Args:
+            value: The indexed value
+            row_id: The row ID to remove
+        """
+        key = _index_key(value)
+        if key in self._index:
+            self._index[key].discard(row_id)
+            if not self._index[key]:
+                del self._index[key]
+                if key is not _NAN:
+                    pos = bisect_left(self._sorted_keys, value)
+                    if pos < len(self._sorted_keys) and self._sorted_keys[pos] == value:
+                        self._sorted_keys.pop(pos)
+
+    def lookup(self, value: Any) -> set[int]:
+        """
+        Look up all row IDs for a given value.
+
+        Args:
+            value: The value to look up
+
+        Returns:
+            Set of row IDs, empty if value not found
+        """
+        return self._index.get(_index_key(value), set()).copy()
+
+    def range_lookup(self, op: str, value: Any) -> set[int]:
+        """
+        Look up row IDs for range conditions.
+
+        Args:
+            op: Comparison operator ('<', '<=', '>', '>=')
+            value: The comparison value
+
+        Returns:
+            Set of row IDs matching the condition
+        """
+        result: set[int] = set()
+        try:
+            if op == '<':
+                # All keys less than value
+                pos = bisect_left(self._sorted_keys, value)
+                for key in self._sorted_keys[:pos]:
+                    result.update(self._index[key])
+            elif op == '<=':
+                # All keys less than or equal to value
+                pos = bisect_right(self._sorted_keys, value)
+                for key in self._sorted_keys[:pos]:
+                    result.update(self._index[key])
+            elif op == '>':
+                # All keys greater than value
+                pos = bisect_right(self._sorted_keys, value)
+                for key in self._sorted_keys[pos:]:
+                    result.update(self._index[key])
+            elif op == '>=':
+                # All keys greater than or equal to value
+                pos = bisect_left(self._sorted_keys, value)
+                for key in self._sorted_keys[pos:]:
+                    result.update(self._index[key])
+        except TypeError as exc:
+            expected = type(self._sorted_keys[0]).__name__ if self._sorted_keys else 'unknown'
+            raise TypeMismatchError(self.column_name, expected, type(value).__name__) from exc
+
+        return result
+
+    def has_value(self, value: Any) -> bool:
+        """Check if a value exists in the index."""
+        return _index_key(value) in self._index
+
+    def clear(self) -> None:
+        """Clear all entries from the index."""
+        self._index.clear()
+        self._sorted_keys.clear()
+
+    def rebuild(self, rows: list[dict], row_ids: list[int]) -> None:
+        """
+        Rebuild the index from scratch.
+
+        Args:
+            rows: List of row dictionaries
+            row_ids: Corresponding row IDs
+        """
+        self.clear()
+        for row, row_id in zip(rows, row_ids, strict=False):
+            if self.column_name in row:
+                value = row[self.column_name]
+                if value is not None:
+                    self.insert(value, row_id)
+
+    @property
+    def size(self) -> int:
+        """Get the number of unique keys in the index."""
+        return len(self._index)
+
+    @property
+    def total_entries(self) -> int:
+        """Get the total number of indexed entries."""
+        return sum(len(ids) for ids in self._index.values())
+
+
+@dataclass
+class IndexManager:
+    """Manages multiple indexes for a table."""
+
+    _indexes: dict[str, HashIndex] = field(default_factory=dict)
+
+    def create_index(self, column_name: str) -> HashIndex:
+        """
+        Create a new index on a column.
+
+        Args:
+            column_name: Name of the column to index
+
+        Returns:
+            The created index
+        """
+        if column_name in self._indexes:
+            raise ValueError(f"Index already exists on column '{column_name}'")
+        index = HashIndex(column_name=column_name)
+        self._indexes[column_name] = index
+        return index
+
+    def get_index(self, column_name: str) -> HashIndex | None:
+        """Get an index by column name."""
+        return self._indexes.get(column_name)
+
+    def has_index(self, column_name: str) -> bool:
+        """Check if an index exists for a column."""
+        return column_name in self._indexes
+
+    def drop_index(self, column_name: str) -> None:
+        """Drop an index by column name."""
+        if column_name in self._indexes:
+            del self._indexes[column_name]
+
+    def insert_row(self, row: dict, row_id: int) -> None:
+        """Insert a row into all indexes."""
+        for column_name, index in self._indexes.items():
+            if column_name in row and row[column_name] is not None:
+                index.insert(row[column_name], row_id)
+
+    def delete_row(self, row: dict, row_id: int) -> None:
+        """Delete a row from all indexes."""
+        for column_name, index in self._indexes.items():
+            if column_name in row and row[column_name] is not None:
+                index.delete(row[column_name], row_id)
+
+    def update_row(self, old_row: dict, new_row: dict, row_id: int) -> None:
+        """Update a row in all indexes."""
+        for column_name, index in self._indexes.items():
+            old_value = old_row.get(column_name)
+            new_value = new_row.get(column_name)
+
+            if old_value != new_value:
+                if old_value is not None:
+                    index.delete(old_value, row_id)
+                if new_value is not None:
+                    index.insert(new_value, row_id)
+
+    def clear(self) -> None:
+        """Clear all indexes."""
+        for index in self._indexes.values():
+            index.clear()