flowmaticdb 1.0.0__py3-none-any.whl

flowmaticdb/__init__.py

@@ -0,0 +1,27 @@
+from flowmaticdb._helpers import (
+    alias,
+    current_timestamp,
+    expression,
+    identifier,
+    now,
+    raw,
+    sub_query,
+)
+from flowmaticdb._query_with_params import QueryWithParams
+from flowmaticdb.exceptions import AdapterError, DatabaseError, DriverError, QueryError, QueryWithParamsError
+
+__all__ = [
+    "AdapterError",
+    "DatabaseError",
+    "DriverError",
+    "QueryError",
+    "QueryWithParams",
+    "QueryWithParamsError",
+    "alias",
+    "current_timestamp",
+    "expression",
+    "identifier",
+    "now",
+    "raw",
+    "sub_query",
+]

flowmaticdb/_helpers.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from typing import Any
+
+from flowmaticdb.query import SelectQuery
+from flowmaticdb.query.expressions._alias import Alias
+from flowmaticdb.query.expressions._current_timestamp import CurrentTimestamp
+from flowmaticdb.query.expressions._expression import Expression
+from flowmaticdb.query.expressions._identifier import Identifier
+from flowmaticdb.query.expressions._raw import Raw
+from flowmaticdb.query.expressions._sub_query import SubQuery
+
+
+def escape_ansi(string: str, chars: str) -> str:
+    return string.translate(str.maketrans(chars, chars * 2))
+
+
+def escape_backslash(string: str, chars: str) -> str:
+    return string.translate(str.maketrans(chars, "\\" + chars))
+
+
+def raw(sql: str) -> Raw:
+    return Raw(sql)
+
+
+def identifier(identifier: str | list[str]) -> Identifier:
+    return Identifier(identifier)
+
+
+def alias(identifier: str | list[str] | Any, alias: str) -> Alias:
+    return Alias(identifier, alias)
+
+
+def expression(sql: str, params: list[Any] | None = None) -> Expression:
+    return Expression(sql, params)
+
+
+def sub_query(query: SelectQuery, alias: str) -> SubQuery:
+    return SubQuery(query, alias)
+
+
+def current_timestamp() -> CurrentTimestamp:
+    return CurrentTimestamp()
+
+
+def now() -> datetime:
+    return datetime.now(UTC)

flowmaticdb/_query_with_params.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from flowmaticdb.dialects._base import DialectABC
+
+REGEX_PATTERN = re.compile(
+    r"""(?x)
+    (?:
+        '(?:\\.|[^\\'])*'
+        |"(?:\\.|[^\\"])*"
+        |`(?:\\.|[^\\`])*`
+        |\[(?:\\.|[^\[\]])*?\]
+        |--[^\r\n]*
+        |/\*[\s\S]*?\*/
+        |\#.*
+    )
+    |
+    (\?)
+    |
+    ((?<!%)%s)
+    """,
+    re.MULTILINE,
+)
+
+
+@dataclass
+class QueryWithParams:
+    query: str
+    params: list[Any] = field(default_factory=list)
+
+    def percent_s_to_question_marks(self) -> QueryWithParams:
+        def _replacer(match: re.Match[str]) -> str:
+            if match.group(2) is not None:
+                return "?"
+            return match.group(0)
+
+        query = REGEX_PATTERN.sub(_replacer, self.query)
+        return QueryWithParams(query=query, params=list(self.params))
+
+    def question_marks_to_percent_s(self) -> QueryWithParams:
+        def _replacer(match: re.Match[str]) -> str:
+            if match.group(1) is not None:
+                return "%s"
+            return match.group(0)
+
+        query = REGEX_PATTERN.sub(_replacer, self.query)
+        return QueryWithParams(query=query, params=list(self.params))
+
+    def to_sql(self, dialect: DialectABC) -> str:
+        param_idx = 0
+
+        def _replacer(match: re.Match[str]) -> str:
+            nonlocal param_idx
+            if match.group(1) is not None or match.group(2) is not None:
+                if param_idx < len(self.params):
+                    value = self.params[param_idx]
+                    casted = dialect.cast_to_query(value)
+                    param_idx += 1
+                    return casted
+                return "?"
+            return match.group(0)
+
+        return REGEX_PATTERN.sub(_replacer, self.query)

flowmaticdb/adapters/__init__.py

@@ -0,0 +1,11 @@
+from flowmaticdb.adapters._base import AdapterABC
+from flowmaticdb.adapters._mysql import MySQLAdapter
+from flowmaticdb.adapters._postgres import PsycopgAdapter
+from flowmaticdb.adapters._sqlite import SQLiteAdapter
+
+__all__ = [
+    "AdapterABC",
+    "MySQLAdapter",
+    "PsycopgAdapter",
+    "SQLiteAdapter",
+]

flowmaticdb/adapters/_base.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
+
+from flowmaticdb.result._base import ResultABC
+
+if TYPE_CHECKING:
+    from flowmaticdb._query_with_params import QueryWithParams
+    from flowmaticdb.dialects._base import DialectABC
+
+
+class AdapterABC(ABC):
+    def __init__(
+        self,
+        driver_name: str,
+        database_name: str,
+        startup_queries: list[str] | None = None,
+        options: dict[str, Any] | None = None,
+        debug_callback: Callable[[str, float, str | None], None] | None = None,
+    ) -> None:
+        self._driver_name = driver_name
+        self._database_name = database_name
+        self._startup_queries = startup_queries or []
+        self._options = options or {}
+        self._debug_callback = debug_callback
+        self._in_transaction = False
+
+    def _exec_startup_queries(self) -> None:
+        for query in self._startup_queries:
+            self.exec(query)
+
+    def _debug(self, sql: str, duration: float, error: str | None = None) -> None:
+        if self._debug_callback is not None:
+            self._debug_callback(sql, duration, error)
+
+    @property
+    def driver_name(self) -> str:
+        return self._driver_name
+
+    @property
+    def database_name(self) -> str:
+        return self._database_name
+
+    @abstractmethod
+    def version(self) -> str:
+        ...
+
+    @abstractmethod
+    def exec(self, query: str) -> None:
+        ...
+
+    @abstractmethod
+    def query(self, query: str) -> ResultABC:
+        ...
+
+    @abstractmethod
+    def query_with_params(
+        self,
+        dialect: DialectABC,
+        query_with_params: QueryWithParams,
+        emulate_prepare: bool = False,
+    ) -> ResultABC:
+        ...
+
+    @abstractmethod
+    def begin_transaction(self) -> None:
+        ...
+
+    @abstractmethod
+    def commit_transaction(self) -> None:
+        ...
+
+    @abstractmethod
+    def rollback_transaction(self) -> None:
+        ...
+
+    @abstractmethod
+    def begin_savepoint(self, name: str) -> None:
+        ...
+
+    @abstractmethod
+    def commit_savepoint(self, name: str) -> None:
+        ...
+
+    @abstractmethod
+    def rollback_savepoint(self, name: str) -> None:
+        ...
+
+    @property
+    @abstractmethod
+    def in_transaction(self) -> bool:
+        ...
+
+    @abstractmethod
+    def last_insert_id(self, name: str | None = None) -> int | str | None:
+        ...

flowmaticdb/adapters/_mysql.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import time
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
+
+from flowmaticdb.adapters._base import AdapterABC
+from flowmaticdb.result._base import ResultABC
+from flowmaticdb.result._mysql import MySQLResult
+
+if TYPE_CHECKING:
+    from flowmaticdb._query_with_params import QueryWithParams
+    from flowmaticdb.dialects._base import DialectABC
+
+
+class MySQLAdapter(AdapterABC):
+    def __init__(
+        self,
+        database_name: str,
+        startup_queries: list[str] | None = None,
+        options: dict[str, Any] | None = None,
+        debug_callback: Callable[[str, float, str | None], None] | None = None,
+        host: str = "localhost",
+        port: int = 3306,
+        user: str = "root",
+        password: str = "",
+    ) -> None:
+        super().__init__(
+            driver_name="mysql",
+            database_name=database_name,
+            startup_queries=startup_queries,
+            options=options,
+            debug_callback=debug_callback,
+        )
+        self._host = host
+        self._port = port
+        self._user = user
+        self._password = password
+        self._connection: Any = None
+        self._current_cursor: Any = None
+        self._connect()
+
+    def _connect(self) -> None:
+        import mysql.connector
+
+        kwargs: dict[str, Any] = {
+            "host": self._host,
+            "port": self._port,
+            "database": self._database_name,
+            "user": self._user,
+            "password": self._password,
+            "autocommit": True,
+        }
+
+        ssl_mode = self._options.get("ssl_mode")
+        if ssl_mode:
+            kwargs["ssl_mode"] = ssl_mode
+
+        connect_timeout = self._options.get("connect_timeout")
+        if connect_timeout:
+            kwargs["connect_timeout"] = connect_timeout
+
+        charset = self._options.get("charset", "utf8mb4")
+        kwargs["charset"] = charset
+
+        self._connection = mysql.connector.connect(**kwargs)
+
+        self._exec_startup_queries()
+
+    def _drain_cursor(self) -> None:
+        """Drain any unread results from the previous cursor.
+
+        MySQL connector forbids creating a new cursor while the previous
+        one still has unread rows.  This method consumes and discards any
+        remaining rows so the next query can proceed.
+        """
+        if self._current_cursor is not None:
+            try:
+                self._current_cursor.fetchall()
+            except Exception:  # noqa: BLE001, S110
+                pass
+            self._current_cursor = None
+
+    def version(self) -> str:
+        try:
+            cursor = self._connection.execute("SELECT VERSION()")
+            row = cursor.fetchone()
+            if row:
+                return str(row[0])
+            return "0"
+        except Exception:  # noqa: BLE001
+            return "0"
+
+    def exec(self, query: str) -> None:
+        start = time.time()
+        error: str | None = None
+        try:
+            self._drain_cursor()
+            cursor = self._connection.cursor()
+            cursor.execute(query)
+        except Exception as e:
+            error = str(e)
+            raise
+        finally:
+            duration = time.time() - start
+            self._debug(query, duration, error)
+
+    def query(self, query: str) -> ResultABC:
+        start = time.time()
+        error: str | None = None
+        try:
+            self._drain_cursor()
+            cursor = self._connection.cursor()
+            cursor.execute(query)
+            self._current_cursor = cursor
+            return MySQLResult(cursor)
+        except Exception as e:
+            error = str(e)
+            raise
+        finally:
+            duration = time.time() - start
+            self._debug(query, duration, error)
+
+    def query_with_params(
+        self,
+        dialect: DialectABC,
+        query_with_params: QueryWithParams,
+        emulate_prepare: bool = False,
+    ) -> ResultABC:
+        query_with_params = query_with_params.question_marks_to_percent_s()
+        sql = query_with_params.query
+        params = query_with_params.params
+
+        start = time.time()
+        error: str | None = None
+        try:
+            self._drain_cursor()
+            if emulate_prepare:
+                sql_full = query_with_params.to_sql(dialect)
+                cursor = self._connection.cursor()
+                cursor.execute(sql_full)
+            else:
+                cursor = self._connection.cursor()
+                cursor.execute(sql, params)
+            self._current_cursor = cursor
+            return MySQLResult(cursor)
+        except Exception as e:
+            error = str(e)
+            raise
+        finally:
+            duration = time.time() - start
+            self._debug(query_with_params.to_sql(dialect), duration, error)
+
+    def begin_transaction(self) -> None:
+        self._connection.start_transaction()
+        self._in_transaction = True
+
+    def commit_transaction(self) -> None:
+        self._connection.commit()
+        self._in_transaction = False
+
+    def rollback_transaction(self) -> None:
+        self._connection.rollback()
+        self._in_transaction = False
+
+    def begin_savepoint(self, name: str) -> None:
+        self._drain_cursor()
+        cursor = self._connection.cursor()
+        cursor.execute(f"SAVEPOINT {name}")
+
+    def commit_savepoint(self, name: str) -> None:
+        self._drain_cursor()
+        cursor = self._connection.cursor()
+        cursor.execute(f"RELEASE SAVEPOINT {name}")
+
+    def rollback_savepoint(self, name: str) -> None:
+        self._drain_cursor()
+        cursor = self._connection.cursor()
+        cursor.execute(f"ROLLBACK TO SAVEPOINT {name}")
+
+    @property
+    def in_transaction(self) -> bool:
+        return self._in_transaction
+
+    def last_insert_id(self, name: str | None = None) -> int | str | None:
+        self._drain_cursor()
+        cursor = self._connection.cursor()
+        cursor.execute("SELECT LAST_INSERT_ID()")
+        row = cursor.fetchone()
+        return row[0] if row else None

flowmaticdb/adapters/_postgres.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import time
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
+
+from flowmaticdb.adapters._base import AdapterABC
+from flowmaticdb.result._base import ResultABC
+from flowmaticdb.result._postgres import PsycopgResult
+
+if TYPE_CHECKING:
+    from flowmaticdb._query_with_params import QueryWithParams
+    from flowmaticdb.dialects._base import DialectABC
+
+
+class PsycopgAdapter(AdapterABC):
+    def __init__(
+        self,
+        database_name: str,
+        startup_queries: list[str] | None = None,
+        options: dict[str, Any] | None = None,
+        debug_callback: Callable[[str, float, str | None], None] | None = None,
+        host: str = "localhost",
+        port: int = 5432,
+        user: str = "postgres",
+        password: str = "",
+    ) -> None:
+        super().__init__(
+            driver_name="postgresql",
+            database_name=database_name,
+            startup_queries=startup_queries,
+            options=options,
+            debug_callback=debug_callback,
+        )
+        self._host = host
+        self._port = port
+        self._user = user
+        self._password = password
+        self._connection: Any = None
+        self._connect()
+
+    def _connect(self) -> None:
+        import psycopg
+
+        kwargs: dict[str, Any] = {
+            "host": self._host,
+            "port": self._port,
+            "dbname": self._database_name,
+            "user": self._user,
+            "password": self._password,
+        }
+
+        ssl_mode = self._options.get("sslmode")
+        if ssl_mode:
+            kwargs["sslmode"] = ssl_mode
+
+        search_path = self._options.get("search_path")
+        if search_path:
+            kwargs["options"] = f"-c search_path={search_path}"
+
+        self._connection = psycopg.connect(**kwargs)
+
+        self._exec_startup_queries()
+
+    def version(self) -> str:
+        try:
+            cursor = self._connection.execute("SELECT version()")
+            row = cursor.fetchone()
+            if row:
+                version_str = str(row[0])
+                import re
+                match = re.search(r'(\d+\.\d+(?:\.\d+)?)', version_str)
+                if match:
+                    return match.group(1)
+            return "0"
+        except Exception:  # noqa: BLE001
+            return "0"
+
+    def exec(self, query: str) -> None:
+        start = time.time()
+        error: str | None = None
+        try:
+            self._connection.execute(query)
+            self._connection.commit()
+        except Exception as e:
+            error = str(e)
+            raise
+        finally:
+            duration = time.time() - start
+            self._debug(query, duration, error)
+
+    def query(self, query: str) -> ResultABC:
+        start = time.time()
+        error: str | None = None
+        try:
+            cursor = self._connection.execute(query)
+            return PsycopgResult(cursor)
+        except Exception as e:
+            error = str(e)
+            raise
+        finally:
+            duration = time.time() - start
+            self._debug(query, duration, error)
+
+    def query_with_params(
+        self,
+        dialect: DialectABC,
+        query_with_params: QueryWithParams,
+        emulate_prepare: bool = False,
+    ) -> ResultABC:
+        query_with_params = query_with_params.question_marks_to_percent_s()
+        sql = query_with_params.query
+        params = query_with_params.params
+
+        start = time.time()
+        error: str | None = None
+        try:
+            if emulate_prepare:
+                sql_full = query_with_params.to_sql(dialect)
+                cursor = self._connection.execute(sql_full)
+            else:
+                cursor = self._connection.execute(sql, params)
+            return PsycopgResult(cursor)
+        except Exception as e:
+            error = str(e)
+            raise
+        finally:
+            duration = time.time() - start
+            self._debug(query_with_params.to_sql(dialect), duration, error)
+
+    def begin_transaction(self) -> None:
+        self._connection.execute("BEGIN TRANSACTION")
+        self._in_transaction = True
+
+    def commit_transaction(self) -> None:
+        self._connection.commit()
+        self._in_transaction = False
+
+    def rollback_transaction(self) -> None:
+        self._connection.rollback()
+        self._in_transaction = False
+
+    def begin_savepoint(self, name: str) -> None:
+        self._connection.execute(f"SAVEPOINT {name}")
+
+    def commit_savepoint(self, name: str) -> None:
+        self._connection.execute(f"RELEASE SAVEPOINT {name}")
+
+    def rollback_savepoint(self, name: str) -> None:
+        self._connection.execute(f"ROLLBACK TO SAVEPOINT {name}")
+
+    @property
+    def in_transaction(self) -> bool:
+        return self._connection.info.transaction_status is not None
+
+    def last_insert_id(self, name: str | None = None) -> int | str | None:
+        if name:
+            cursor = self._connection.execute(f"SELECT currval('{name}')")
+        else:
+            cursor = self._connection.execute("SELECT lastval()")
+        row = cursor.fetchone()
+        return row[0] if row else None