dataclassdb 0.1.0__py3-none-any.whl

dataclassdb/constants.py

@@ -0,0 +1,372 @@
+__all__ = [
+    "SQL",
+    "SQL_FUNC",
+    "SQL_TYPES",
+    "SQL_TYPES_EXTENDED",
+    "SQL_FUNC_PRAGMA",
+    "SQL_FUNC_PRAGMA_EXTENDED",
+]
+
+from enum import StrEnum, auto
+from dataclassdb.utils import UpperStrEnum
+
+
+class SQL(UpperStrEnum):
+    ABORT = auto()
+    ACTION = auto()
+    ADD = auto()
+    AFTER = auto()
+    ALL = auto()
+    ALTER = auto()
+    ALWAYS = auto()
+    ANALYZE = auto()
+    AND = auto()
+    AS = auto()
+    ASC = auto()
+    ATTACH = auto()
+    AUTOINCREMENT = auto()
+    BEFORE = auto()
+    BEGIN = auto()
+    BETWEEN = auto()
+    BY = auto()
+    CASCADE = auto()
+    CASE = auto()
+    CAST = auto()
+    CHECK = auto()
+    COLLATE = auto()
+    COLUMN = auto()
+    COMMIT = auto()
+    CONFLICT = auto()
+    CONSTRAINT = auto()
+    CREATE = auto()
+    CROSS = auto()
+    CURRENT = auto()
+    CURRENT_DATE = auto()
+    CURRENT_TIME = auto()
+    CURRENT_TIMESTAMP = auto()
+    DATABASE = auto()
+    DEFAULT = auto()
+    DEFERRABLE = auto()
+    DEFERRED = auto()
+    DELETE = auto()
+    DESC = auto()
+    DETACH = auto()
+    DISTINCT = auto()
+    DO = auto()
+    DROP = auto()
+    EACH = auto()
+    ELSE = auto()
+    END = auto()
+    ESCAPE = auto()
+    EXCEPT = auto()
+    EXCLUDE = auto()
+    EXCLUSIVE = auto()
+    EXISTS = auto()
+    EXPLAIN = auto()
+    FAIL = auto()
+    FILTER = auto()
+    FIRST = auto()
+    FOLLOWING = auto()
+    FOR = auto()
+    FOREIGN = auto()
+    FROM = auto()
+    FULL = auto()
+    GENERATED = auto()
+    GLOB = auto()
+    GROUP = auto()
+    GROUPS = auto()
+    HAVING = auto()
+    IF = auto()
+    IGNORE = auto()
+    IMMEDIATE = auto()
+    IN = auto()
+    INDEX = auto()
+    INDEXED = auto()
+    INITIALLY = auto()
+    INNER = auto()
+    INSERT = auto()
+    INSTEAD = auto()
+    INTERSECT = auto()
+    INTO = auto()
+    IS = auto()
+    ISNULL = auto()
+    JOIN = auto()
+    KEY = auto()
+    LAST = auto()
+    LEFT = auto()
+    LIKE = auto()
+    LIMIT = auto()
+    MATCH = auto()
+    MATERIALIZED = auto()
+    NATURAL = auto()
+    NO = auto()
+    NOT = auto()
+    NOTHING = auto()
+    NOTNULL = auto()
+    NULL = auto()
+    NULLS = auto()
+    OF = auto()
+    OFFSET = auto()
+    ON = auto()
+    OR = auto()
+    ORDER = auto()
+    OTHERS = auto()
+    OUTER = auto()
+    OVER = auto()
+    PARTITION = auto()
+    PLAN = auto()
+    PRAGMA = auto()
+    PRECEDING = auto()
+    PRIMARY = auto()
+    PRIMARY_KEY = auto()  # Manually adding PRIMARY KEY
+    QUERY = auto()
+    RAISE = auto()
+    RANGE = auto()
+    RECURSIVE = auto()
+    REFERENCES = auto()
+    REGEXP = auto()
+    REINDEX = auto()
+    RELEASE = auto()
+    RENAME = auto()
+    REPLACE = auto()
+    RESTRICT = auto()
+    RETURNING = auto()
+    RIGHT = auto()
+    ROLLBACK = auto()
+    ROW = auto()
+    ROWS = auto()
+    SAVEPOINT = auto()
+    SELECT = auto()
+    SET = auto()
+    STORED = auto()  # https://sqlite.org/gencol.html
+    TABLE = auto()
+    TEMP = auto()
+    TEMPORARY = auto()
+    THEN = auto()
+    TIES = auto()
+    TO = auto()
+    TRANSACTION = auto()
+    TRIGGER = auto()
+    UNBOUNDED = auto()
+    UNION = auto()
+    UNIQUE = auto()
+    UPDATE = auto()
+    USING = auto()
+    VACUUM = auto()
+    VALUES = auto()
+    VIEW = auto()
+    VIRTUAL = auto()
+    WHEN = auto()
+    WHERE = auto()
+    WINDOW = auto()
+    WITH = auto()
+    WITHOUT = auto()
+
+    INTEGER = auto()
+    TEXT = auto()
+    BLOB = auto()
+    REAL = auto()
+    NUMERIC = auto()
+    ANY = auto()  # FOR STRICT TABLE
+
+    OLD = auto()  # Added to support CreateTrigger Queries https://www.sqlite.org/lang_createtrigger.html
+
+
+class SQL_FUNC(StrEnum):
+    # https://sqlite.org/lang_corefunc.html
+    ABS = auto()
+    CHANGES = auto()
+    CHAR = auto()
+    COALESCE = auto()
+    CONCAT = auto()
+    CONCAT_WS = auto()
+    FORMAT = auto()
+    GLOB = auto()
+    HEX = auto()
+    IF = auto()
+    IFNULL = auto()
+    IIF = auto()
+    INSTR = auto()
+    LAST_INSERT_ROWID = auto()
+    LENGTH = auto()
+    LIKE = auto()
+    LIKELIHOOD = auto()
+    LIKELY = auto()
+    LOAD_EXTENSION = auto()
+    LOWER = auto()
+    LTRIM = auto()
+    MAX = auto()
+    MIN = auto()
+    NULLIF = auto()
+    OCTET_LENGTH = auto()
+    PRINTF = auto()
+    QUOTE = auto()
+    RANDOM = auto()
+    RANDOMBLOB = auto()
+    REPLACE = auto()
+    ROUND = auto()
+    RTRIM = auto()
+    SIGN = auto()
+    SOUNDEX = auto()
+    SQLITE_COMPILEOPTION_GET = auto()
+    SQLITE_COMPILEOPTION_USED = auto()
+    SQLITE_OFFSET = auto()
+    SQLITE_SOURCE_ID = auto()
+    SQLITE_VERSION = auto()
+    SUBSTR = auto()
+    SUBSTRING = auto()
+    TOTAL_CHANGES = auto()
+    TRIM = auto()
+    TYPEOF = auto()
+    UNHEX = auto()
+    UNICODE = auto()
+    UNISTR = auto()
+    UNISTR_QUOTE = auto()
+    UNLIKELY = auto()
+    UPPER = auto()
+    ZEROBLOB = auto()
+
+    # https://sqlite.org/lang_aggfunc.html
+    AVG = auto()
+    GROUP_CONCAT = auto()
+    MEDIAN = auto()
+    PERCENTILE = auto()
+    PERCENTILE_CONT = auto()
+    PERCENTILE_DISC = auto()
+    STRING_AGG = auto()
+    SUM = auto()
+    TOTAL = auto()
+    COUNT = auto()
+
+    # https://sqlite.org/lang_datefunc.html
+    DATE = auto()
+    TIME = auto()
+    DATETIME = auto()
+    JULIANDAY = auto()
+    UNIXEPOCH = auto()
+    STRFTIME = auto()
+    TIMEDIFF = auto()
+
+    INTEGER = auto()
+    TEXT = auto()
+    BLOB = auto()
+    REAL = auto()
+    NUMERIC = auto()
+    ANY = auto()  # FOR STRICT TABLE
+
+
+class SQL_TYPES(StrEnum):
+    # https://sqlite.org/datatype3.html
+    # https://sqlite.org/stricttables.html
+    INTEGER = auto()
+    TEXT = auto()
+    BLOB = auto()
+    REAL = auto()
+    NUMERIC = auto()
+    ANY = auto()  # FOR STRICT TABLE
+
+
+class SQL_TYPES_EXTENDED(UpperStrEnum):
+    INTEGER = auto()
+    TEXT = auto()
+    BLOB = auto()
+    REAL = auto()
+    NUMERIC = auto()
+    ANY = auto()  # FOR STRICT TABLE
+    INT = auto()
+    TINYINT = auto()
+    SMALLINT = auto()
+    MEDIUMINT = auto()
+    BIGINT = auto()
+    UNSIGNED_BIG_INT = auto()
+    INT2 = auto()
+    INT8 = auto()
+    CHARACTER = auto()
+    VARCHAR = auto()
+    VARYING_CHARACTER = auto()
+    NCHAR = auto()
+    NATIVE_CHARACTER = auto()
+    NVARCHAR = auto()
+    CLOB = auto()
+    DOUBLE = auto()
+    DOUBLE_PRECISION = auto()
+    FLOAT = auto()
+    DECIMAL = auto()
+    BOOLEAN = auto()
+    DATE = auto()
+    DATETIME = auto()
+
+
+class SQL_FUNC_PRAGMA(StrEnum):
+    # https://sqlite.org/pragma.html
+    ANALYSIS_LIMIT = auto()
+    APPLICATION_ID = auto()
+    AUTO_VACUUM = auto()
+    AUTOMATIC_INDEX = auto()
+    BUSY_TIMEOUT = auto()
+    CACHE_SIZE = auto()
+    CACHE_SPILL = auto()
+    CELL_SIZE_CHECK = auto()
+    CHECKPOINT_FULLFSYNC = auto()
+    COLLATION_LIST = auto()
+    COMPILE_OPTIONS = auto()
+    DATA_VERSION = auto()
+    DATABASE_LIST = auto()
+    DEFER_FOREIGN_KEYS = auto()
+    ENCODING = auto()
+    FOREIGN_KEY_CHECK = auto()
+    FOREIGN_KEY_LIST = auto()
+    FOREIGN_KEYS = auto()
+    FREELIST_COUNT = auto()
+    FULLFSYNC = auto()
+    FUNCTION_LIST = auto()
+    HARD_HEAP_LIMIT = auto()
+    IGNORE_CHECK_CONSTRAINTS = auto()
+    INCREMENTAL_VACUUM = auto()
+    INDEX_INFO = auto()
+    INDEX_LIST = auto()
+    INDEX_XINFO = auto()
+    INTEGRITY_CHECK = auto()
+    JOURNAL_MODE = auto()
+    JOURNAL_SIZE_LIMIT = auto()
+    LEGACY_ALTER_TABLE = auto()
+    LEGACY_FILE_FORMAT = auto()
+    LOCKING_MODE = auto()
+    MAX_PAGE_COUNT = auto()
+    MMAP_SIZE = auto()
+    MODULE_LIST = auto()
+    OPTIMIZE = auto()
+    PAGE_COUNT = auto()
+    PAGE_SIZE = auto()
+    PRAGMA_LIST = auto()
+    QUERY_ONLY = auto()
+    QUICK_CHECK = auto()
+    READ_UNCOMMITTED = auto()
+    RECURSIVE_TRIGGERS = auto()
+    REVERSE_UNORDERED_SELECTS = auto()
+    SECURE_DELETE = auto()
+    SHRINK_MEMORY = auto()
+    SOFT_HEAP_LIMIT = auto()
+    SYNCHRONOUS = auto()
+    TABLE_INFO = auto()
+    TABLE_LIST = auto()
+    TABLE_XINFO = auto()
+    TEMP_STORE = auto()
+    THREADS = auto()
+    TRUSTED_SCHEMA = auto()
+    USER_VERSION = auto()
+    WAL_AUTOCHECKPOINT = auto()
+    WAL_CHECKPOINT = auto()
+
+
+class SQL_FUNC_PRAGMA_EXTENDED(StrEnum):
+    # https://sqlite.org/pragma.html
+    # Non-Standard and testing commands
+    PARSER_TRACE = auto()
+    SCHEMA_VERSION = auto()
+    STATS = auto()
+    VDBE_ADDOPTRACE = auto()
+    VDBE_DEBUG = auto()
+    VDBE_LISTING = auto()
+    VDBE_TRACE = auto()
+    WRITABLE_SCHEMA = auto()

dataclassdb/dataclass_db.py

@@ -0,0 +1,282 @@
+import logging
+import sqlite3
+from dataclasses import is_dataclass
+from typing import Any, TypeVar
+
+from dataclassdb.builders.query_builder import QueryBuilder
+from dataclassdb.dataclass_sqlite_table import get_class_codec
+from dataclassdb.constants import SQL
+
+# from dataclassdb.types import T
+from dataclassdb.dataclass_types import IsDataclass
+from dataclassdb.utils import table_exists
+
+logger = logging.getLogger(__name__)
+
+DataclassT = TypeVar("DataclassT", bound=IsDataclass)
+
+
+class DataclassDb(QueryBuilder):
+    primary_key_map: dict[Any, list[str]] = {}
+    unique_map: dict[Any, list[str]] = {}
+
+    def __init__(
+        self,
+        data_class: DataclassT,
+        connection: str | sqlite3.Connection,
+        table_name="",
+    ):
+        super().__init__(connection=connection)
+        if not is_dataclass(data_class):
+            raise TypeError(f"Class {data_class.__name__} is not a dataclass")
+        if not connection:
+            raise ConnectionError("Connection must be set.")
+        self.data_class = data_class
+        self.table_name = table_name if table_name else data_class.__name__
+        self.insert_query = None
+        self.primary_keys = []
+        self.unique = []
+        self.codec = get_class_codec(data_class)
+        self.connection_name = ""
+        for name, _field in self.codec.class_fields.items():
+            if _field.primary_key:
+                self.primary_keys.append(name)
+            if _field.unique:
+                self.unique.append(name)
+        self.create_or_update_table()
+
+    def __contains__(self, key) -> bool:
+        try:
+            query = (
+                QueryBuilder()
+                .SELECT(1)
+                .FROM(self.table_name)
+                .WHERE(self.key_match_str())
+                .LIMIT(1)
+            )
+            result = self.execute_one(
+                *self.parse_key(key), sql_str=str(query), as_dict=False
+            )
+            return result is not None
+        finally:
+            self.clear
+
+    def __setitem__(self, key, value) -> DataclassT:
+        self.insert(value)
+
+    def key_match_str(self):
+        return " AND ".join([f"{key} = ?" for key in self.primary_keys])
+
+    def get_current_table_query(self) -> str:
+        row = (
+            QueryBuilder(self.connection)
+            .SELECT("sql")
+            .FROM("sqlite_master")
+            .WHERE("type")
+            .eq.quote("table")
+            .AND("name")
+            .eq.quote(self.table_name)
+            .end.execute_one(as_dict=False)
+        )
+        return row[0] if row else ""
+
+    def parse_key(self, key):
+        if not isinstance(key, tuple):
+            if isinstance(key, list):
+                key = tuple(key)
+            else:
+                key = (key,)
+        if len(self.primary_keys) != len(key):
+            raise KeyError(
+                "Input of (%s) does not match length of primary key (%s)",
+                key,
+                self.primary_keys,
+            )
+        return key
+
+    def insert(self, item: DataclassT):
+        params = self.codec.encode(item, as_tuple=False, ignore_none=True)
+
+        field_names = params.keys()
+        query = (
+            QueryBuilder()
+            .INSERT.INTO(self.table_name)
+            .par(*field_names)
+            .br.VALUES.placeholders(*field_names)
+        )
+        if self.primary_keys:
+            if len(self.primary_keys) < len(self.codec.class_fields):
+                (
+                    query.br.ON.CONFLICT.par(*self.primary_keys).br.DO.UPDATE.SET(
+                        *[
+                            f"{col} = excluded.{col}"
+                            for col in field_names
+                            if col not in self.primary_keys
+                            # and col not in self.codec.on_conflict_ignore
+                        ]
+                    )
+                )
+            else:
+                query.ON.CONFLICT.par(*self.primary_keys).DO.NOTHING
+            query.br.RETURNING(*self.primary_keys)
+        else:
+            query.br.RETURNING("rowid")
+        return self.execute_one(*params.values(), sql_str=query)
+
+    def get(
+        self, key, select_fields: list[str] = None, as_dict=False, as_tuple=False
+    ) -> DataclassT:
+        if self.primary_keys == []:
+            return self.peek(key, select_fields, as_dict, as_tuple)
+        if as_dict and as_tuple:
+            raise ValueError("as_dict and as _tuple cannot both be true")
+        if select_fields and not as_dict and not as_tuple:
+            raise ValueError(
+                "If select fields are provided either as_dict or as_tuple must be true."
+            )
+        if not select_fields:
+            field_str = "*"
+        else:
+            field_str = ", ".join(select_fields)
+        query = (
+            QueryBuilder()
+            .SELECT(field_str)
+            .FROM(self.table_name)
+            .WHERE(self.key_match_str())
+        )
+        row_dict: dict = self.execute_one(
+            *self.parse_key(key),
+            sql_str=str(query),
+            as_dict=True,
+        )
+        as_obj = not (as_tuple or as_dict)
+        decoded = self.codec.decode(row_dict, as_obj=as_obj)
+        if as_tuple:
+            return tuple(decoded.values())
+        else:
+            return decoded
+
+    def peek(
+        self, rowid=None, select_fields: list[str] = None, as_dict=False, as_tuple=False
+    ):
+        if as_dict and as_tuple:
+            raise ValueError("as_dict and as _tuple cannot both be true")
+        if select_fields and not as_dict and not as_tuple:
+            raise ValueError(
+                "If select fields are provided either as_dict or as_tuple must be true."
+            )
+        if not select_fields:
+            field_str = "*"
+        else:
+            field_str = ", ".join(select_fields)
+        query = QueryBuilder().SELECT(field_str).FROM(self.table_name)
+        if rowid is not None:
+            query.WHERE("rowid").eq("?")
+        query.ORDER.BY("rowid").DESC
+        if rowid:
+            row_dict: dict = self.execute_one(
+                rowid,
+                sql_str=str(query),
+                as_dict=True,
+            )
+        else:
+            row_dict: dict = self.execute_one(
+                sql_str=str(query),
+                as_dict=True,
+            )
+        as_obj = not (as_tuple or as_dict)
+        decoded = self.codec.decode(row_dict, as_obj=as_obj)
+        if as_tuple:
+            return tuple(decoded.values())
+        else:
+            return decoded
+
+    def delete(self, key) -> DataclassT:
+        query = QueryBuilder().DELETE.FROM(self.table_name).WHERE(self.key_match_str())
+        self.execute_one(*self.parse_key(key), sql_str=str(query))
+
+    def create_or_update_table(self):
+        logger.info("Creating or updating table %s", self.table_name)
+        if not table_exists(self.connection, self.table_name):
+            logger.info("Table %s does not exist. Creating table.", self.table_name)
+            query = QueryBuilder().add(self.sql_create_table())
+            self.execute_one(sql_str=str(query))
+            # query.execute_one()
+
+        elif self.get_curr_cols(self.data_class) != self.dataclass_sql_cols():
+            logger.info(
+                "Table %s does exist but does not match the dataclass. Attempting to update table..",
+                self.table_name,
+            )
+            fields_list = self.get_current_fields(self.table_name)
+
+            curr_fields = {f.name: f for f in fields_list}
+            dc_fields = self.codec.class_fields
+            overlapping_fields = []
+            for dc_field, dc_item in dc_fields.items():
+                if curr_fields.get(dc_field, None):
+                    overlapping_fields.append(dc_field)
+            temp_table = f"temp_{self.table_name}"
+            logger.info(
+                "Attempting to update table on these overlapping fields",
+                self.table_name,
+                overlapping_fields,
+            )
+            if overlapping_fields:
+                query = (
+                    QueryBuilder()
+                    .BEGIN.IMMEDIATE.TRANSACTION.end.br(
+                        self.sql_create_table(temp_table)
+                    )
+                    .br.INSERT.INTO(temp_table)
+                    .par(*overlapping_fields)
+                    .br.SELECT(*overlapping_fields)
+                    .FROM(self.table_name)
+                    .end.br.DROP.TABLE.IF.EXISTS(self.table_name)
+                    .end.br.ALTER.TABLE(temp_table)
+                    .RENAME.TO(self.table_name)
+                )
+                self.execute_script(sql_script=str(query))
+            else:
+                logger.warning(
+                    "Table for dataclass %s has changed with no overlapping fields. Deleting table and creating a new one.",
+                    self.data_class.__name__,
+                )
+                query = (
+                    QueryBuilder()
+                    .BEGIN.IMMEDIATE.TRANSACTION.end.br.DROP.TABLE.IF.EXISTS(
+                        self.table_name
+                    )
+                    .end.br(self.sql_create_table())
+                    .br
+                )
+                self.execute_script(sql_script=str(query))
+            logger.info(
+                "Table creation for %s successful.", self.table_name, overlapping_fields
+            )
+        else:
+            logger.info("Table has not changed.")
+
+    def sql_create_table(self, table_name=None) -> str:
+        table_name = table_name if table_name else self.table_name
+        cols_str = ",\n".join(self.dataclass_sql_cols())
+        return (
+            QueryBuilder()
+            .CREATE.TABLE.IF.NOT.EXISTS(table_name)
+            .par(f"\n{cols_str}\n")
+            .end
+        )
+
+    def dataclass_sql_cols(self):
+        """Returns a list of SQL columns used in CREATE TABLE"""
+        #
+        params = []
+        for name, f in self.codec.class_fields.items():
+            params.append(
+                f.sql_col_def(len(self.primary_keys) > 1, len(self.unique) > 1)
+            )
+        if len(self.primary_keys) > 1:
+            params.append(f"{SQL.PRIMARY_KEY}({', '.join(self.primary_keys)})")
+        if len(self.unique) > 1:
+            params.append(f"{SQL.UNIQUE}({', '.join(self.unique)})")
+        return params