sqlqb 0.1.2__tar.gz → 0.1.4__tar.gz

sqlqb-0.1.4/.envrc

@@ -0,0 +1,3 @@
+layout_ide
+
+export PYTHONSTARTUP=.pythonrc.py

sqlqb-0.1.4/.pythonrc.py

@@ -0,0 +1 @@
+from sqlqb import *  # noqa: F403

{sqlqb-0.1.2 → sqlqb-0.1.4}/PKG-INFO

@@ -1,5 +1,5 @@
 Metadata-Version: 2.4
 Name: sqlqb
-Version: 0.1.2
+Version: 0.1.4
 Summary: A simple sql query builder
 Requires-Python: >=3.12

{sqlqb-0.1.2 → sqlqb-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlqb"
-version = "0.1.2"
+version = "0.1.4"
 description = "A simple sql query builder"
 readme = "README.md"
 authors = []
@@ -13,6 +13,12 @@ dev = [
     "pytest-cov>=7.1.0",
     "ruff>=0.15.17",
 ]
+pymysql = [
+    "pymysql>=1.2.0",
+]
+sqlalchemy = [
+    "sqlalchemy>=2.0.51",
+]
 
 [build-system]
 requires = ["hatchling", "hatch-vcs"]

{sqlqb-0.1.2 → sqlqb-0.1.4}/src/sqlqb/delete.py

@@ -6,6 +6,7 @@ class Delete:
         self.__table: str | None = None
         self.__wheres: list[str] = []
         self.__params: list = []
+        self.__named_params: dict = {}
         self.__limit: int | None = None
 
     def From(self, table: str) -> "Delete":
@@ -14,9 +15,18 @@ class Delete:
         self.__table = table
         return self
 
-    def Where(self, condition: str, *args) -> "Delete":
+    def Where(self, condition: str, *args, **kwargs) -> "Delete":
+        if args and kwargs:
+            raise ValueError("error: cannot mix positional and named params")
+        if args and self.__named_params:
+            raise ValueError("error: cannot mix positional and named params")
+        if kwargs and self.__params:
+            raise ValueError("error: cannot mix positional and named params")
         self.__wheres.append(condition)
-        self.__params += args
+        if kwargs:
+            self.__named_params.update(kwargs)
+        else:
+            self.__params += list(args)
         return self
 
     def Limit(self, limit: int) -> "Delete":
@@ -24,7 +34,9 @@ class Delete:
         return self
 
     @property
-    def params(self) -> list:
+    def params(self) -> list | dict:
+        if self.__named_params:
+            return self.__named_params
         return self.__params
 
     @property

{sqlqb-0.1.2/src/sqlqb/mysql → sqlqb-0.1.4/src/sqlqb/pymysql}/__init__.py

@@ -1,3 +1,5 @@
+import re
+
 from pymysql.connections import Connection as _Connection
 from pymysql.cursors import DictCursor
 
@@ -7,59 +9,72 @@ from sqlqb import Update as _Update
 from sqlqb import Delete as _Delete
 
 
+def _to_pymysql(sql: str, params: list | dict) -> tuple[str, list | dict]:
+    """Convert :name placeholders to %(name)s style for PyMySQL when params is a dict."""
+    if isinstance(params, dict):
+        sql = re.sub(r":([a-zA-Z_][a-zA-Z0-9_]*)", r"%(\1)s", sql)
+    return sql, params
+
+
 class Select(_Select):
-    def __init__(self, connection, *args):
+    def __init__(self, connection: _Connection, *args):
         super().__init__(*args)
         self.__connection = connection
 
     def execute(self):
+        sql, params = _to_pymysql(self.sql, self.params)
         cursor = self.__connection.cursor()
-        cursor.execute(self.sql, self.params)
+        cursor.execute(sql, params)
         return cursor
 
     def fetchone(self):
+        sql, params = _to_pymysql(self.sql, self.params)
         with self.__connection.cursor() as cursor:
-            cursor.execute(self.sql, self.params)
+            cursor.execute(sql, params)
             result = cursor.fetchone()
         return result
 
     def fetchall(self):
+        sql, params = _to_pymysql(self.sql, self.params)
         with self.__connection.cursor() as cursor:
-            cursor.execute(self.sql, self.params)
+            cursor.execute(sql, params)
             result = cursor.fetchall()
         return result
 
 
 class Insert(_Insert):
-    def __init__(self, connection):
+    def __init__(self, connection: _Connection):
         super().__init__()
         self.__connection = connection
 
     def execute(self) -> int:
+        sql, params = _to_pymysql(self.sql, self.params)
         with self.__connection.cursor() as cursor:
-            cursor.execute(self.sql, self.params)
+            cursor.execute(sql, params)
             return cursor.rowcount
 
 
 class Update(_Update):
-    def __init__(self, connection, table: str):
+    def __init__(self, connection: _Connection, table: str):
         super().__init__(table)
         self.__connection = connection
 
     def execute(self) -> int:
+        sql, params = _to_pymysql(self.sql, self.params)
         with self.__connection.cursor() as cursor:
-            cursor.execute(self.sql, self.params)
+            cursor.execute(sql, params)
             return cursor.rowcount
 
 
 class Delete(_Delete):
-    def __init__(self, connection):
+    def __init__(self, connection: _Connection):
         super().__init__()
         self.__connection = connection
 
     def execute(self) -> int:
+        sql, params = _to_pymysql(self.sql, self.params)
         with self.__connection.cursor() as cursor:
-            cursor.execute(self.sql, self.params)
+            cursor.execute(sql, params)
             return cursor.rowcount
 
 
@@ -75,8 +90,11 @@ class Connection(_Connection):
     def Insert(self) -> Insert:
         return Insert(self)
 
+    def Update(self, table: str) -> Update:
+        return Update(self, table)
+
     def Delete(self) -> Delete:
         return Delete(self)
 
-    def Update(self, table: str) -> Update:
-        return Update(self, table)
+
+connect = Connection

{sqlqb-0.1.2 → sqlqb-0.1.4}/src/sqlqb/select.py

@@ -7,6 +7,7 @@ class Select:
         self.__table: str | None = None
         self.__wheres: list[str] = []
         self.__params: list = []
+        self.__named_params: dict = {}
         self.__joins: list[str] = []
         self.__orderby: list[tuple[str, str]] = []
         self.__groupby: list[str] = []
@@ -25,14 +26,32 @@ class Select:
         self.__table = table
         return self
 
-    def Join(self, join: str, *args) -> "Select":
+    def Join(self, join: str, *args, **kwargs) -> "Select":
+        if args and kwargs:
+            raise ValueError("error: cannot mix positional and named params")
+        if args and self.__named_params:
+            raise ValueError("error: cannot mix positional and named params")
+        if kwargs and self.__params:
+            raise ValueError("error: cannot mix positional and named params")
         self.__joins.append(join)
-        self.__params += args
+        if kwargs:
+            self.__named_params.update(kwargs)
+        else:
+            self.__params += list(args)
         return self
 
-    def Where(self, condition: str, *args) -> "Select":
+    def Where(self, condition: str, *args, **kwargs) -> "Select":
+        if args and kwargs:
+            raise ValueError("error: cannot mix positional and named params")
+        if args and self.__named_params:
+            raise ValueError("error: cannot mix positional and named params")
+        if kwargs and self.__params:
+            raise ValueError("error: cannot mix positional and named params")
         self.__wheres.append(condition)
-        self.__params += args
+        if kwargs:
+            self.__named_params.update(kwargs)
+        else:
+            self.__params += list(args)
         return self
 
     def OrderBy(self, column: str, direction: str = "ASC") -> "Select":
@@ -54,7 +73,9 @@ class Select:
         return self
 
     @property
-    def params(self) -> list:
+    def params(self) -> list | dict:
+        if self.__named_params:
+            return self.__named_params
         return self.__params
 
     @property
@@ -62,8 +83,9 @@ class Select:
         sql = io.StringIO()
         sql.write("SELECT ")
         sql.write(", ".join(self.__columns or "*"))
-        sql.write(" FROM ")
-        sql.write(self.__table)
+        if self.__table:
+            sql.write(" FROM ")
+            sql.write(self.__table)
         if self.__joins:
             sql.write(" ")
             sql.write(" ".join(self.__joins))

sqlqb-0.1.4/src/sqlqb/sqlalchemy/__init__.py

@@ -0,0 +1,97 @@
+from sqlalchemy import create_engine as _create_engine
+from sqlalchemy import text
+from sqlalchemy.engine import Connection as _Connection
+from sqlalchemy.engine import Engine as _Engine
+
+from sqlqb import Select as _Select
+from sqlqb import Insert as _Insert
+from sqlqb import Update as _Update
+from sqlqb import Delete as _Delete
+
+
+def _bind(sql: str, params: list | dict) -> tuple[str, dict]:
+    """Convert params for SQLAlchemy text(): pass dicts through, replace ? with :p0/:p1/... for lists."""
+    if isinstance(params, dict):
+        return sql, params
+    named: dict = {}
+    for i, val in enumerate(params):
+        key = f"p{i}"
+        sql = sql.replace("?", f":{key}", 1)
+        named[key] = val
+    return sql, named
+
+
+class Select(_Select):
+    def __init__(self, connection: _Connection, *args):
+        super().__init__(*args)
+        self.__connection = connection
+
+    def execute(self):
+        sql, params = _bind(self.sql, self.params)
+        return self.__connection.execute(text(sql), params)
+
+    def fetchone(self):
+        sql, params = _bind(self.sql, self.params)
+        row = self.execute().mappings().fetchone()
+        return dict(row) if row is not None else None
+
+    def fetchall(self) -> list:
+        sql, params = _bind(self.sql, self.params)
+        return [dict(row) for row in self.execute().mappings()]
+
+
+class Insert(_Insert):
+    def __init__(self, connection: _Connection):
+        super().__init__()
+        self.__connection = connection
+
+    def execute(self) -> int:
+        sql, params = _bind(self.sql, self.params)
+        return self.__connection.execute(text(sql), params).rowcount
+
+
+class Update(_Update):
+    def __init__(self, connection: _Connection, table: str):
+        super().__init__(table)
+        self.__connection = connection
+
+    def execute(self) -> int:
+        sql, params = _bind(self.sql, self.params)
+        return self.__connection.execute(text(sql), params).rowcount
+
+
+class Delete(_Delete):
+    def __init__(self, connection: _Connection):
+        super().__init__()
+        self.__connection = connection
+
+    def execute(self) -> int:
+        sql, params = _bind(self.sql, self.params)
+        return self.__connection.execute(text(sql), params).rowcount
+
+
+class Connection(_Connection):
+    def Select(self, *args) -> Select:
+        return Select(self, *args)
+
+    def Insert(self) -> Insert:
+        return Insert(self)
+
+    def Update(self, table: str) -> Update:
+        return Update(self, table)
+
+    def Delete(self) -> Delete:
+        return Delete(self)
+
+
+class Engine(_Engine):
+    def connect(self) -> Connection:
+        conn = super().connect()
+        conn.__class__ = Connection
+        return conn
+
+
+def create_engine(url: str, **kwargs) -> Engine:
+    engine = _create_engine(url, **kwargs)
+    engine.__class__ = Engine
+    return engine

{sqlqb-0.1.2/src/sqlqb/sqlite → sqlqb-0.1.4/src/sqlqb/sqlite3}/__init__.py

@@ -1,4 +1,6 @@
-import sqlite3
+from sqlite3 import Connection as _Connection
+from sqlite3 import Cursor as _Cursor
+from sqlite3 import connect as _connect
 
 from sqlqb import Select as _Select
 from sqlqb import Insert as _Insert
@@ -7,11 +9,11 @@ from sqlqb import Delete as _Delete
 
 
 class Select(_Select):
-    def __init__(self, connection, *args):
+    def __init__(self, connection: _Connection, *args):
         super().__init__(*args)
         self.__connection = connection
 
-    def execute(self) -> sqlite3.Cursor:
+    def execute(self) -> _Cursor:
         return self.__connection.execute(self.sql, self.params)
 
     def fetchone(self):
@@ -22,7 +24,7 @@ class Select(_Select):
 
 
 class Insert(_Insert):
-    def __init__(self, connection):
+    def __init__(self, connection: _Connection):
         super().__init__()
         self.__connection = connection
 
@@ -31,7 +33,7 @@ class Insert(_Insert):
 
 
 class Update(_Update):
-    def __init__(self, connection, table: str):
+    def __init__(self, connection: _Connection, table: str):
         super().__init__(table)
         self.__connection = connection
 
@@ -40,7 +42,7 @@ class Update(_Update):
 
 
 class Delete(_Delete):
-    def __init__(self, connection):
+    def __init__(self, connection: _Connection):
         super().__init__()
         self.__connection = connection
 
@@ -48,7 +50,7 @@ class Delete(_Delete):
         return self.__connection.execute(self.sql, self.params).rowcount
 
 
-class Connection(sqlite3.Connection):
+class Connection(_Connection):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.row_factory = lambda cursor, row: dict(zip([col[0] for col in cursor.description], row))
@@ -59,12 +61,12 @@ class Connection(sqlite3.Connection):
     def Insert(self) -> Insert:
         return Insert(self)
 
-    def Delete(self) -> Delete:
-        return Delete(self)
-
     def Update(self, table: str) -> Update:
         return Update(self, table)
 
+    def Delete(self) -> Delete:
+        return Delete(self)
+
 
 def connect(database, **kwargs) -> Connection:
-    return sqlite3.connect(database, factory=Connection, **kwargs)
+    return _connect(database, factory=Connection, **kwargs)

{sqlqb-0.1.2 → sqlqb-0.1.4}/src/sqlqb/update.py

@@ -9,6 +9,7 @@ class Update:
         self.__sets: dict[str, object] = {}
         self.__wheres: list[str] = []
         self.__where_params: list = []
+        self.__where_named_params: dict = {}
         self.__limit: int | None = None
 
     def Set(self, **kwargs) -> "Update":
@@ -17,9 +18,18 @@ class Update:
         self.__sets.update(kwargs)
         return self
 
-    def Where(self, condition: str, *args) -> "Update":
+    def Where(self, condition: str, *args, **kwargs) -> "Update":
+        if args and kwargs:
+            raise ValueError("error: cannot mix positional and named params")
+        if args and self.__where_named_params:
+            raise ValueError("error: cannot mix positional and named params")
+        if kwargs and self.__where_params:
+            raise ValueError("error: cannot mix positional and named params")
         self.__wheres.append(condition)
-        self.__where_params += args
+        if kwargs:
+            self.__where_named_params.update(kwargs)
+        else:
+            self.__where_params += list(args)
         return self
 
     def Limit(self, limit: int) -> "Update":
@@ -27,9 +37,13 @@ class Update:
         return self
 
     @property
-    def params(self) -> list:
+    def params(self) -> list | dict:
         if not self.__sets:
             return []
+        if self.__where_named_params:
+            named = dict(self.__sets)
+            named.update(self.__where_named_params)
+            return named
         return list(self.__sets.values()) + self.__where_params
 
     @property
@@ -40,7 +54,10 @@ class Update:
         sql.write("UPDATE ")
         sql.write(self.__table)
         sql.write(" SET ")
-        sql.write(", ".join([f"{col} = ?" for col in self.__sets]))
+        if self.__where_named_params:
+            sql.write(", ".join([f"{col} = :{col}" for col in self.__sets]))
+        else:
+            sql.write(", ".join([f"{col} = ?" for col in self.__sets]))
         if self.__wheres:
             sql.write(" WHERE ")
             sql.write(" AND ".join(self.__wheres))

sqlqb-0.1.4/tests/test_pymysql.py

@@ -0,0 +1,223 @@
+import pytest
+from unittest.mock import MagicMock, patch
+
+from sqlqb import pymysql
+from sqlqb.pymysql import Select, Insert, Update, Delete, Connection
+from pymysql.cursors import DictCursor
+
+
+@pytest.fixture
+def mock_conn():
+    """Mock pymysql connection whose cursor supports both direct use and context manager."""
+    conn = MagicMock()
+    cursor = MagicMock()
+    conn.cursor.return_value = cursor
+    cursor.__enter__.return_value = cursor
+    cursor.__exit__.return_value = False
+    return conn, cursor
+
+
+@pytest.fixture
+def connection():
+    """pymysql.Connection instance with the pymysql parent __init__ patched out."""
+    with patch.object(pymysql._Connection, "__init__", return_value=None):
+        conn = pymysql.Connection.__new__(pymysql.Connection)
+        yield conn
+
+
+class TestSelect:
+    def test_execute_returns_cursor(self, mock_conn):
+        conn, cursor = mock_conn
+        result = Select(conn, "id", "name").From("users").execute()
+        assert result is cursor
+
+    def test_execute_calls_cursor_execute_with_sql_and_params(self, mock_conn):
+        conn, cursor = mock_conn
+        q = Select(conn, "name").From("users").Where("id = ?", 1)
+        q.execute()
+        cursor.execute.assert_called_once_with(q.sql, q.params)
+
+    def test_execute_does_not_use_context_manager(self, mock_conn):
+        conn, cursor = mock_conn
+        Select(conn, "id").From("users").execute()
+        cursor.__enter__.assert_not_called()
+
+    def test_fetchone_returns_result(self, mock_conn):
+        conn, cursor = mock_conn
+        cursor.fetchone.return_value = {"id": 1, "name": "Alice"}
+        result = Select(conn, "id", "name").From("users").Where("id = ?", 1).fetchone()
+        assert result == {"id": 1, "name": "Alice"}
+
+    def test_fetchone_returns_none_when_no_row(self, mock_conn):
+        conn, cursor = mock_conn
+        cursor.fetchone.return_value = None
+        result = Select(conn, "id").From("users").Where("id = ?", 999).fetchone()
+        assert result is None
+
+    def test_fetchone_calls_cursor_execute(self, mock_conn):
+        conn, cursor = mock_conn
+        q = Select(conn, "name").From("users").Where("id = ?", 1)
+        q.fetchone()
+        cursor.execute.assert_called_once_with(q.sql, q.params)
+
+    def test_fetchone_uses_context_manager(self, mock_conn):
+        conn, cursor = mock_conn
+        Select(conn, "name").From("users").fetchone()
+        cursor.__enter__.assert_called_once()
+
+    def test_fetchall_returns_result(self, mock_conn):
+        conn, cursor = mock_conn
+        cursor.fetchall.return_value = [{"id": 1}, {"id": 2}]
+        result = Select(conn, "id").From("users").fetchall()
+        assert result == [{"id": 1}, {"id": 2}]
+
+    def test_fetchall_returns_empty_list(self, mock_conn):
+        conn, cursor = mock_conn
+        cursor.fetchall.return_value = []
+        result = Select(conn, "id").From("users").fetchall()
+        assert result == []
+
+    def test_fetchall_calls_cursor_execute(self, mock_conn):
+        conn, cursor = mock_conn
+        q = Select(conn, "id").From("users")
+        q.fetchall()
+        cursor.execute.assert_called_once_with(q.sql, q.params)
+
+    def test_fetchall_uses_context_manager(self, mock_conn):
+        conn, cursor = mock_conn
+        Select(conn, "id").From("users").fetchall()
+        cursor.__enter__.assert_called_once()
+
+    def test_multiple_where_params_passed_correctly(self, mock_conn):
+        conn, cursor = mock_conn
+        q = Select(conn, "name").From("users").Where("age > ?", 18).Where("active = ?", True)
+        q.fetchall()
+        cursor.execute.assert_called_once_with(q.sql, [18, True])
+
+    def test_chaining_with_order_and_limit(self, mock_conn):
+        conn, cursor = mock_conn
+        cursor.fetchall.return_value = [{"name": "Alice"}]
+        result = Select(conn, "name").From("users").Where("age >= ?", 18).OrderBy("name").Limit(1).fetchall()
+        assert result == [{"name": "Alice"}]
+
+
+class TestInsert:
+    def test_execute_returns_rowcount(self, mock_conn):
+        conn, cursor = mock_conn
+        cursor.rowcount = 1
+        count = Insert(conn).Into("users").Values(id=1, name="Alice").execute()
+        assert count == 1
+
+    def test_execute_calls_cursor_execute(self, mock_conn):
+        conn, cursor = mock_conn
+        q = Insert(conn).Into("users").Values(id=1, name="Alice")
+        q.execute()
+        cursor.execute.assert_called_once_with(q.sql, q.params)
+
+    def test_execute_uses_context_manager(self, mock_conn):
+        conn, cursor = mock_conn
+        Insert(conn).Into("users").Values(id=1, name="Alice").execute()
+        cursor.__enter__.assert_called_once()
+
+    def test_execute_multiple_rows_rowcount(self, mock_conn):
+        conn, cursor = mock_conn
+        cursor.rowcount = 2
+        count = Insert(conn).Into("users").Values(id=1, name="Alice").Values(id=2, name="Bob").execute()
+        assert count == 2
+
+
+class TestUpdate:
+    def test_execute_returns_rowcount(self, mock_conn):
+        conn, cursor = mock_conn
+        cursor.rowcount = 1
+        count = Update(conn, "users").Set(name="Alice").Where("id = ?", 1).execute()
+        assert count == 1
+
+    def test_execute_calls_cursor_execute(self, mock_conn):
+        conn, cursor = mock_conn
+        q = Update(conn, "users").Set(name="Alice").Where("id = ?", 1)
+        q.execute()
+        cursor.execute.assert_called_once_with(q.sql, q.params)
+
+    def test_execute_uses_context_manager(self, mock_conn):
+        conn, cursor = mock_conn
+        Update(conn, "users").Set(name="Alice").execute()
+        cursor.__enter__.assert_called_once()
+
+    def test_execute_no_where_returns_affected_rowcount(self, mock_conn):
+        conn, cursor = mock_conn
+        cursor.rowcount = 5
+        count = Update(conn, "users").Set(active=False).execute()
+        assert count == 5
+
+    def test_execute_multiple_set_columns(self, mock_conn):
+        conn, cursor = mock_conn
+        cursor.rowcount = 1
+        q = Update(conn, "users").Set(name="Bob", age=20).Where("id = ?", 2)
+        count = q.execute()
+        cursor.execute.assert_called_once_with(q.sql, q.params)
+        assert count == 1
+
+
+class TestDelete:
+    def test_execute_returns_rowcount(self, mock_conn):
+        conn, cursor = mock_conn
+        cursor.rowcount = 1
+        count = Delete(conn).From("users").Where("id = ?", 1).execute()
+        assert count == 1
+
+    def test_execute_calls_cursor_execute(self, mock_conn):
+        conn, cursor = mock_conn
+        q = Delete(conn).From("users").Where("id = ?", 1)
+        q.execute()
+        cursor.execute.assert_called_once_with(q.sql, q.params)
+
+    def test_execute_uses_context_manager(self, mock_conn):
+        conn, cursor = mock_conn
+        Delete(conn).From("users").Where("id = ?", 1).execute()
+        cursor.__enter__.assert_called_once()
+
+    def test_execute_no_where_returns_all_rowcount(self, mock_conn):
+        conn, cursor = mock_conn
+        cursor.rowcount = 3
+        count = Delete(conn).From("users").execute()
+        assert count == 3
+
+    def test_execute_with_limit(self, mock_conn):
+        conn, cursor = mock_conn
+        cursor.rowcount = 2
+        q = Delete(conn).From("users").Limit(2)
+        count = q.execute()
+        cursor.execute.assert_called_once_with(q.sql, q.params)
+        assert count == 2
+
+
+class TestConnection:
+    def test_default_cursorclass_is_dictcursor(self):
+        with patch.object(pymysql._Connection, "__init__", return_value=None) as mock_init:
+            Connection(host="localhost", user="root", password="secret", db="mydb")
+            kwargs = mock_init.call_args[1]
+            assert kwargs["cursorclass"] is DictCursor
+
+    def test_custom_cursorclass_is_not_overridden(self):
+        custom_cursor = MagicMock()
+        with patch.object(pymysql._Connection, "__init__", return_value=None) as mock_init:
+            Connection(host="localhost", cursorclass=custom_cursor)
+            kwargs = mock_init.call_args[1]
+            assert kwargs["cursorclass"] is custom_cursor
+
+    def test_select_returns_select_instance(self, connection):
+        result = connection.Select("id", "name")
+        assert isinstance(result, Select)
+
+    def test_insert_returns_insert_instance(self, connection):
+        result = connection.Insert()
+        assert isinstance(result, Insert)
+
+    def test_delete_returns_delete_instance(self, connection):
+        result = connection.Delete()
+        assert isinstance(result, Delete)
+
+    def test_update_returns_update_instance(self, connection):
+        result = connection.Update("users")
+        assert isinstance(result, Update)

sqlqb-0.1.4/tests/test_sqlalchemy.py

@@ -0,0 +1,226 @@
+import pytest
+from sqlalchemy import text
+from sqlalchemy.engine import Connection as _SAConnection, Engine as _SAEngine
+from sqlalchemy.pool import StaticPool
+
+from sqlqb.sqlalchemy import Connection, Engine, create_engine
+
+
+@pytest.fixture(scope="module")
+def engine():
+    e = create_engine(
+        "sqlite:///:memory:",
+        connect_args={"check_same_thread": False},
+        poolclass=StaticPool,
+    )
+    with e.connect() as conn:
+        conn.execute(text("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, age INTEGER)"))
+        conn.Insert().Into("users").Values(id=1, name="Alice", age=30).execute()
+        conn.Insert().Into("users").Values(id=2, name="Bob", age=17).execute()
+        conn.Insert().Into("users").Values(id=3, name="Carol", age=25).execute()
+        conn.commit()
+    return e
+
+
+@pytest.fixture
+def conn(engine):
+    with engine.connect() as c:
+        yield c
+        c.rollback()
+
+
+# ---------------------------------------------------------------------------
+# Engine
+# ---------------------------------------------------------------------------
+
+
+class TestEngine:
+    def test_create_engine_returns_engine_subclass(self):
+        e = create_engine("sqlite:///:memory:")
+        assert isinstance(e, Engine)
+        assert isinstance(e, _SAEngine)
+
+    def test_connect_returns_connection_subclass(self, engine):
+        with engine.connect() as conn:
+            assert isinstance(conn, Connection)
+            assert isinstance(conn, _SAConnection)
+
+    def test_connect_as_context_manager(self, engine):
+        with engine.connect() as conn:
+            assert conn is not None
+
+    def test_connect_without_context_manager(self, engine):
+        conn = engine.connect()
+        assert isinstance(conn, Connection)
+        conn.close()
+
+    def test_engine_dialect_accessible(self):
+        e = create_engine("sqlite:///:memory:")
+        assert e.dialect.name == "sqlite"
+
+    def test_engine_dispose(self):
+        e = create_engine("sqlite:///:memory:")
+        e.dispose()
+
+
+# ---------------------------------------------------------------------------
+# Connection
+# ---------------------------------------------------------------------------
+
+
+class TestConnection:
+    def test_sa_methods_are_accessible(self, conn):
+        assert callable(conn.commit)
+        assert callable(conn.rollback)
+        assert callable(conn.close)
+        assert callable(conn.execute)
+
+    def test_select_returns_select_instance(self, conn):
+        from sqlqb.sqlalchemy import Select
+
+        assert isinstance(conn.Select("id"), Select)
+
+    def test_insert_returns_insert_instance(self, conn):
+        from sqlqb.sqlalchemy import Insert
+
+        assert isinstance(conn.Insert(), Insert)
+
+    def test_update_returns_update_instance(self, conn):
+        from sqlqb.sqlalchemy import Update
+
+        assert isinstance(conn.Update("users"), Update)
+
+    def test_delete_returns_delete_instance(self, conn):
+        from sqlqb.sqlalchemy import Delete
+
+        assert isinstance(conn.Delete(), Delete)
+
+
+# ---------------------------------------------------------------------------
+# Select
+# ---------------------------------------------------------------------------
+
+
+class TestSelect:
+    def test_fetchall(self, conn):
+        rows = conn.Select("id", "name").From("users").fetchall()
+        assert rows == [{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}, {"id": 3, "name": "Carol"}]
+
+    def test_fetchone(self, conn):
+        row = conn.Select("name").From("users").Where("id = ?", 1).fetchone()
+        assert row == {"name": "Alice"}
+
+    def test_fetchone_returns_none_when_no_row(self, conn):
+        row = conn.Select("name").From("users").Where("id = ?", 999).fetchone()
+        assert row is None
+
+    def test_fetchall_returns_empty_list(self, conn):
+        rows = conn.Select("name").From("users").Where("id = ?", 999).fetchall()
+        assert rows == []
+
+    def test_where_single_param(self, conn):
+        rows = conn.Select("name").From("users").Where("age >= ?", 18).fetchall()
+        assert rows == [{"name": "Alice"}, {"name": "Carol"}]
+
+    def test_where_multiple_params(self, conn):
+        rows = conn.Select("name").From("users").Where("age >= ?", 18).Where("age <= ?", 29).fetchall()
+        assert rows == [{"name": "Carol"}]
+
+    def test_order_by_asc(self, conn):
+        rows = conn.Select("name").From("users").OrderBy("name").fetchall()
+        assert rows == [{"name": "Alice"}, {"name": "Bob"}, {"name": "Carol"}]
+
+    def test_order_by_desc(self, conn):
+        rows = conn.Select("name").From("users").OrderBy("age", "DESC").fetchall()
+        assert rows == [{"name": "Alice"}, {"name": "Carol"}, {"name": "Bob"}]
+
+    def test_limit(self, conn):
+        rows = conn.Select("id").From("users").Limit(2).fetchall()
+        assert rows == [{"id": 1}, {"id": 2}]
+
+    def test_execute_returns_sa_result(self, conn):
+        result = conn.Select("id", "name").From("users").execute()
+        rows = [dict(r) for r in result.mappings()]
+        assert rows == [{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}, {"id": 3, "name": "Carol"}]
+
+    def test_fetchall_returns_plain_dicts(self, conn):
+        rows = conn.Select("id").From("users").Limit(1).fetchall()
+        assert type(rows[0]) is dict
+
+    def test_fetchone_returns_plain_dict(self, conn):
+        row = conn.Select("id").From("users").Where("id = ?", 1).fetchone()
+        assert type(row) is dict
+
+
+# ---------------------------------------------------------------------------
+# Insert
+# ---------------------------------------------------------------------------
+
+
+class TestInsert:
+    def test_execute_returns_rowcount(self, conn):
+        count = conn.Insert().Into("users").Values(id=4, name="Dave", age=40).execute()
+        assert count == 1
+
+    def test_inserted_row_is_queryable(self, conn):
+        conn.Insert().Into("users").Values(id=4, name="Dave", age=40).execute()
+        row = conn.Select("name").From("users").Where("id = ?", 4).fetchone()
+        assert row == {"name": "Dave"}
+
+    def test_insert_multiple_rows(self, conn):
+        count = conn.Insert().Into("users").Values(id=4, name="Dave", age=40).Values(id=5, name="Eve", age=22).execute()
+        assert count == 2
+
+
+# ---------------------------------------------------------------------------
+# Update
+# ---------------------------------------------------------------------------
+
+
+class TestUpdate:
+    def test_execute_returns_rowcount(self, conn):
+        count = conn.Update("users").Set(name="Alicia").Where("id = ?", 1).execute()
+        assert count == 1
+
+    def test_update_is_reflected(self, conn):
+        conn.Update("users").Set(name="Alicia").Where("id = ?", 1).execute()
+        row = conn.Select("name").From("users").Where("id = ?", 1).fetchone()
+        assert row == {"name": "Alicia"}
+
+    def test_update_multiple_columns(self, conn):
+        conn.Update("users").Set(name="Bobby", age=18).Where("id = ?", 2).execute()
+        row = conn.Select("name", "age").From("users").Where("id = ?", 2).fetchone()
+        assert row == {"name": "Bobby", "age": 18}
+
+    def test_update_no_where_affects_all(self, conn):
+        count = conn.Update("users").Set(age=0).execute()
+        assert count == 3
+
+    def test_update_affects_correct_rows_only(self, conn):
+        conn.Update("users").Set(age=99).Where("id = ?", 1).execute()
+        rows = conn.Select("id", "age").From("users").fetchall()
+        assert rows == [{"id": 1, "age": 99}, {"id": 2, "age": 17}, {"id": 3, "age": 25}]
+
+
+# ---------------------------------------------------------------------------
+# Delete
+# ---------------------------------------------------------------------------
+
+
+class TestDelete:
+    def test_execute_returns_rowcount(self, conn):
+        conn.Insert().Into("users").Values(id=4, name="Temp", age=1).execute()
+        count = conn.Delete().From("users").Where("id = ?", 4).execute()
+        assert count == 1
+
+    def test_deleted_row_is_gone(self, conn):
+        conn.Insert().Into("users").Values(id=4, name="Temp", age=1).execute()
+        conn.Delete().From("users").Where("id = ?", 4).execute()
+        row = conn.Select("*").From("users").Where("id = ?", 4).fetchone()
+        assert row is None
+
+    def test_delete_no_where_clears_table(self, conn):
+        count = conn.Delete().From("users").execute()
+        assert count == 3
+        rows = conn.Select("*").From("users").fetchall()
+        assert rows == []

sqlqb-0.1.2/tests/test_sqlite.py → sqlqb-0.1.4/tests/test_sqlite3.py

@@ -1,11 +1,11 @@
 import pytest
 
-from sqlqb import sqlite
+from sqlqb import sqlite3
 
 
 @pytest.fixture
 def conn():
-    c = sqlite.connect(":memory:")
+    c = sqlite3.connect(":memory:")
     c.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, age INTEGER)")
     c.executemany("INSERT INTO users VALUES (?, ?, ?)", [(1, "Alice", 30), (2, "Bob", 17), (3, "Carol", 25)])
     c.commit()
@@ -30,13 +30,7 @@ class TestSelect:
         assert cursor.fetchone() == {"id": 1, "name": "Alice", "age": 30}
 
     def test_chaining(self, conn):
-        rows = (
-            conn.Select("name")
-            .From("users")
-            .Where("age >= ?", 18)
-            .OrderBy("name")
-            .fetchall()
-        )
+        rows = conn.Select("name").From("users").Where("age >= ?", 18).OrderBy("name").fetchall()
         assert rows == [{"name": "Alice"}, {"name": "Carol"}]
 
     def test_limit(self, conn):
@@ -107,6 +101,7 @@ class TestDelete:
 
     def test_delete_with_limit_not_supported(self, conn):
         # NOTE: sqlite library of python does not support LIMIT in delete queries
-        import sqlite3
-        with pytest.raises(sqlite3.OperationalError):
+        import sqlite3 as stdlib_sqlite3
+
+        with pytest.raises(stdlib_sqlite3.OperationalError):
             conn.Delete().From("users").Limit(2).execute()

{sqlqb-0.1.2 → sqlqb-0.1.4}/uv.lock

@@ -95,6 +95,61 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/8a/3c/1a983b9a745d7f83d53f057bcc5bf79ba6a2bbc08266b3f0c7d6fe630c9b/coverage-7.14.1-py3-none-any.whl", hash = "sha256:a252f21c27e38347e60111a3266b03827422a7d5525951aceee313aa68bab1d2", size = 211815, upload-time = "2026-05-26T20:41:34.078Z" },
 ]
 
+[[package]]
+name = "greenlet"
+version = "3.5.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/dd/8b/befc3cb36965f397d87e86fb3b00e3ec0dc67c1ecb0986d7f54ee528f018/greenlet-3.5.2.tar.gz", hash = "sha256:c1b906220d83c140361cdd12eef970fb5881a168b98ee58a43786426173da14c", size = 199243, upload-time = "2026-06-17T20:19:01.317Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3f/7a/6bc2a7835731387ed303b9390ce68a116ab053df05450a59181239200454/greenlet-3.5.2-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:76dae33e97b52743a19210931ee3e78a88fe1438bc2fc4ee5e7512d289bfad4f", size = 288351, upload-time = "2026-06-17T17:36:17.019Z" },
+    { url = "https://files.pythonhosted.org/packages/57/1b/bd98062fcef6d0e9d0873ab6f2d029772e6ea342972ae43275bd6177900f/greenlet-3.5.2-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:30252d191d6959df1d040b559a38fc017139606c5ecc2ad00416557c0355d742", size = 604273, upload-time = "2026-06-17T18:07:20.296Z" },
+    { url = "https://files.pythonhosted.org/packages/25/e6/fe392c522bf45d976abe7db2793f6ef4e87b053ebb869deeaae46aeb54da/greenlet-3.5.2-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1adc23c50f22b0f5979521909a8360ab4a3d3bef8b641ce633a04cf1b1c967ea", size = 616536, upload-time = "2026-06-17T18:29:43.205Z" },
+    { url = "https://files.pythonhosted.org/packages/68/4a/399ff81fa93a19d6a9df394cef0355f082dbc19ad41aba9593cd0ad444e2/greenlet-3.5.2-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1f052fff492c52fdfa99bd3b3c1389a53de37dae76a0562741417f0d018f02b3", size = 613749, upload-time = "2026-06-17T17:39:28.148Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/75/f519593f12ad43d08e28c03a95cfe2eeae011707dbc9dab0c4a263ce90f9/greenlet-3.5.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:120b77c2a18ebf629c3a7886f68c6d01e065654844ad468f15bb93ace66f2094", size = 1573725, upload-time = "2026-06-17T18:22:12.023Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/bc/bc1ea4b0754c6c51bbf9d94677b0b1f7fbda8cbb404e44a896854fc0a940/greenlet-3.5.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a850f6224088ef7dcc70f1a545cb6b3d119c35d6dca63b925b9f35da0635cdad", size = 1638132, upload-time = "2026-06-17T17:40:06.971Z" },
+    { url = "https://files.pythonhosted.org/packages/36/c0/f0f5a34247df60de285f75f22e57f14027f4b3c43820981854b5b643ca6d/greenlet-3.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:89da99ee8345b458ea2f16831dad31c88ddcdec454b48704d569a0b8fb28f146", size = 239393, upload-time = "2026-06-17T17:33:47.09Z" },
+    { url = "https://files.pythonhosted.org/packages/09/17/a8544e165445f30aea67a8d9cf2786d2bb0eb1b0e0d224b4d9bd80e2d587/greenlet-3.5.2-cp312-cp312-win_arm64.whl", hash = "sha256:ca92411942154023c65851e6077d8ca0d00f19de5fa80bb2c6f196ff6c920ba9", size = 237723, upload-time = "2026-06-17T17:36:47.776Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/3c/bb37b9d40d65b0741a8b040ca5c307034d0a9822994dff5f825c88dd7a6b/greenlet-3.5.2-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:0629377725977252159de1ebd3c6e49c170a63856e585446797bb3d66d4d9c34", size = 287178, upload-time = "2026-06-17T17:35:25.132Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/a6/0c5902393f492f8ceb19d0b5cf139284e3a11b333a049739643b1036b6f8/greenlet-3.5.2-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a2ddf9eddc617681108dd071b3feabf3f4a4cd64846254aec4d4ceda098b639a", size = 606900, upload-time = "2026-06-17T18:07:21.692Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/7c/42899c31d4b87148ae4e3f87f63e13398824be6241f4dde42ded95768a34/greenlet-3.5.2-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f41feb9f2b59e2e61ac9bea4e344ddd9396bf3cacb2583f73a3595ed7df6f8e7", size = 619265, upload-time = "2026-06-17T18:29:44.837Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/52/4ff8c98d3cfe62b4515f8584ae14510a58f35c549cc5292b78d9b7a40b70/greenlet-3.5.2-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:09201fa698768db245920b00fdc86ee3e73540f01ca6db162be9632642e1a473", size = 616187, upload-time = "2026-06-17T17:39:29.473Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/a6/269c8bf9aefc13361ce1088f0e392b154cb21005de7862e42b5d782b81fd/greenlet-3.5.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a1759fa4f14c398508cf20dc8037de55cc23ae8bd14c185c2718257837195ca5", size = 1573778, upload-time = "2026-06-17T18:22:13.497Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/9b/391d015cbc6323e81b14c02cf825fdca7e0049c9bb489bf4ac72883118ba/greenlet-3.5.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b9318cdeb9abdbfdd8bc8464ee4a06dffde2c7846e1def138365a6240ab2c9a5", size = 1638092, upload-time = "2026-06-17T17:40:08.163Z" },
+    { url = "https://files.pythonhosted.org/packages/49/53/5b4df711f4356c62e85d9f819d87966d526d1cfb32bae49a8f7d6fc36ea4/greenlet-3.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:2c3b3311af72b3d3b03cc0f1ffd11f072e834be5d0444105cf715fc44434e39c", size = 239352, upload-time = "2026-06-17T17:38:51.593Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/b6/18efc3a329ec035c3f344b8f2b60356451950ddf9b7b64ff00023778a1dd/greenlet-3.5.2-cp313-cp313-win_arm64.whl", hash = "sha256:f9bbd6216c45a563c2a61e478e038b439d9f248bde44f775ea37d339da643af4", size = 237635, upload-time = "2026-06-17T17:35:36.632Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/89/aaafc8e14de4ac882e02ccb963225329b0e8578aba4365e71eb678e45722/greenlet-3.5.2-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:1c31219badba285858ba8ed117f403dea7fafee6bade9a1991875aae530c3ceb", size = 287676, upload-time = "2026-06-17T17:33:31.514Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/fc/2308249206c12ac70de7b9a00970f84f07d10b3cd60e05d2fbcaa84124e8/greenlet-3.5.2-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6f96ed6f4adc1066954ae95f45717657cb67468ef3b89e9a3632e14a625a8f39", size = 653552, upload-time = "2026-06-17T18:07:23.493Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/24/47730d1f8f1336b9b089237521ed7a26eee997065dcb4cab81cdca333abc/greenlet-3.5.2-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5795e883e915333c0d5648faaa691857fbc7180136883edc377f50f0d509c2a8", size = 665756, upload-time = "2026-06-17T18:29:46.616Z" },
+    { url = "https://files.pythonhosted.org/packages/99/69/d6c99db15dc0b5e892ac3cc7b942c8b21f4a9cc3bd9ea0bc3b0f339ffbd4/greenlet-3.5.2-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:26aed8d9503ca78889141a9739d71b383efea5f472a7c522b5410f7eb2a1b163", size = 663228, upload-time = "2026-06-17T17:39:31.073Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/88/9e603f448e2bc107c883e95817b980fb9b45ba6aea0299b2e9978124bea2/greenlet-3.5.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:dbebc038fcdda8f8f21cce985fd04e34e0f42007e7fc7ab7ad285caf77974b95", size = 1620723, upload-time = "2026-06-17T18:22:14.817Z" },
+    { url = "https://files.pythonhosted.org/packages/11/91/26da17e3777858c16fdb8d020a4c68f3a03cb92f238de8f5351d5d5186e9/greenlet-3.5.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a207023f1cf8695fd82580b8099c09c5809be18bc2282362cdfb965dd884a317", size = 1684227, upload-time = "2026-06-17T17:40:09.536Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/44/b3a11f7aa34cb38f1b7f3df8bcd9fcd09bac9d342c2a2c9b8686c804bcd2/greenlet-3.5.2-cp314-cp314-win_amd64.whl", hash = "sha256:c674a1dd4fe41f6a93febe7ab366ceabf15080ea31a9307811c56dac5f435f73", size = 240257, upload-time = "2026-06-17T17:35:23.359Z" },
+    { url = "https://files.pythonhosted.org/packages/de/e3/3b62145fe917311732041a258adb218248add00542e3131c48bd047fbed5/greenlet-3.5.2-cp314-cp314-win_arm64.whl", hash = "sha256:3c417cd6c593bbbef6f7aa31a79f37d3db7d18832fc56b694a2150130bde784e", size = 239038, upload-time = "2026-06-17T17:37:56.792Z" },
+    { url = "https://files.pythonhosted.org/packages/47/ac/d3bad483e9f6cd1848604fdffa32cac25846dd6dfcec0e6f81c790185518/greenlet-3.5.2-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:a96457a30384de52d9c5d2fd33abf6c1daae3db392cd556738f408b1a79a1cf0", size = 295668, upload-time = "2026-06-17T17:36:02.293Z" },
+    { url = "https://files.pythonhosted.org/packages/00/e9/3a7e557b895fd0469b00cd0b2bd498ba950e8bfdf6d7adeecf2c5e4130a6/greenlet-3.5.2-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4af5d4961818ab651d09c1448a03b1ba2a1726a076266ebb62330bab9f3238c", size = 652820, upload-time = "2026-06-17T18:07:24.95Z" },
+    { url = "https://files.pythonhosted.org/packages/78/67/6225d5c5e4afc04be0fd161eec82e4b72017e8a100d222f25d7b42b0140d/greenlet-3.5.2-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a1789a6244ea1ba61fd4386c9a6a31873e9b0234762103364be98ef87dcb19f3", size = 658697, upload-time = "2026-06-17T18:29:48.365Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/99/6324b8ef916dcaddccb340b304c992ca3f947614ce0f2685d438187300b8/greenlet-3.5.2-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3be00501fb4a8c37f6b4b3c4773808ceb26ea65c7ea64fd5735d0f330b3786de", size = 656436, upload-time = "2026-06-17T17:39:32.509Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/ee/f5bf9daac27c5e1b011965f64b5630a32b415daf7381b312943629e12c2a/greenlet-3.5.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:1d554cd96841a68d464d75a3736f8e87408a7b02b1930a75fa32feb408ad62f8", size = 1617193, upload-time = "2026-06-17T18:22:16.252Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/21/b05d5b12715bda92ce27c118d64971d21e9b8f3563ed959a7d271e2d4223/greenlet-3.5.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3dff6cd3aac35f6cd3fc23460105acf576f5faf6c378de0bc088bf37c913864a", size = 1677512, upload-time = "2026-06-17T17:40:10.771Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/97/1b8f1314b868041b327dc1051603e8142b826480cb0ecb8a7b7632aee9c4/greenlet-3.5.2-cp314-cp314t-win_amd64.whl", hash = "sha256:36cfea2aa075d544617176b2e84450480f0797070ad8799a8c41ada2fe449d32", size = 243145, upload-time = "2026-06-17T17:34:37.502Z" },
+    { url = "https://files.pythonhosted.org/packages/36/07/1b5311775e04c718a118c504d7a3a312430e2a1bd1347226aff4774e4549/greenlet-3.5.2-cp315-cp315-macosx_11_0_universal2.whl", hash = "sha256:a0314aa832c94633355dc6f3ee54f195159533355a323f26926fc63b98b2ccbb", size = 288315, upload-time = "2026-06-17T17:34:34.04Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/cc/6abcd2a486b58b9f77b7a93b690d59cb2c11a5906ed2ad4c63c7b9c1113d/greenlet-3.5.2-cp315-cp315-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:24c59cb7db9d5c694cb8fd0c76eef8e456b2123afdfa7e4b8f2a67a0860d7682", size = 659130, upload-time = "2026-06-17T18:07:26.354Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/12/f4aaad6d3d383233f700ab322568a4f29f2c701a4861d85f4811d99689b2/greenlet-3.5.2-cp315-cp315-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7bb811753703739ad318112f16eccfaabdac050037b6d092debaa8b23566b4ce", size = 669724, upload-time = "2026-06-17T18:29:50.13Z" },
+    { url = "https://files.pythonhosted.org/packages/91/2a/a089811fc31c6bf8742f40a4e73470d6d401cef18e4314eb20dc399b377c/greenlet-3.5.2-cp315-cp315-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6d78b5c1c178dad90447f1b8452262709d3eef4c98f825569e74c9d0b2260ac9", size = 668089, upload-time = "2026-06-17T17:39:33.808Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/1c/2f47c7d5fcfa98a62b705bf9a0505d86f4563c0d81cab1f7159ff1e743b7/greenlet-3.5.2-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:0977af2df83136f81c1f76e76d4e2fe7d0dc56ea9c101a86af26a95190b9ca32", size = 1625684, upload-time = "2026-06-17T18:22:17.664Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/bf/661dd24624f70b7b32972d7693d0344ecde10278f647d7b828baf739899c/greenlet-3.5.2-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:f9ed777c6891d8253e54468576f55e27f8fc1a662a664f946a191003574c0a74", size = 1688043, upload-time = "2026-06-17T17:40:12.403Z" },
+    { url = "https://files.pythonhosted.org/packages/60/49/d9bde1d15a21296b3b521fe083eb8aabd54ac05d15de9832918f3d639543/greenlet-3.5.2-cp315-cp315-win_amd64.whl", hash = "sha256:c0ea4eb3de23f0bac1d75205e10ccfa9b418b17b01a2d7bf19e3b69dda08900a", size = 240531, upload-time = "2026-06-17T17:35:47.448Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/4d/86d7768bd53e9907de0333df215c2018cd01a593b3715cbd79aa82dd94b7/greenlet-3.5.2-cp315-cp315-win_arm64.whl", hash = "sha256:7a7bfc200be40d04961d7e80e8337d726c0c1a50777e588123c3ed8ba731dcb9", size = 239579, upload-time = "2026-06-17T17:39:39.954Z" },
+    { url = "https://files.pythonhosted.org/packages/92/15/907be5e8900901039bae752fa9a31c03a3c1e064833f35a4e49449184581/greenlet-3.5.2-cp315-cp315t-macosx_11_0_universal2.whl", hash = "sha256:98a52d6a50d4deaba304331d83ee3e10ebbdc1517fcca40b2715d1de4534065c", size = 296697, upload-time = "2026-06-17T17:37:15.887Z" },
+    { url = "https://files.pythonhosted.org/packages/95/5c/08c57be575c3d6a3c023bbf22144a1c7dc6ed4d134527bb36ded4dbf04a8/greenlet-3.5.2-cp315-cp315t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1587ff8b58fdf806993ed1490a06ac19c22d47b219c68b30954380029045d8d4", size = 656710, upload-time = "2026-06-17T18:07:28.046Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/d0/749f917bdc9fc90fceea4aa65fbf6556e617a50714d1496bdc8ad190bb36/greenlet-3.5.2-cp315-cp315t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:feb721811d2754bfd16b48de151dd6b1f222c048e625151f2ca44cfdfd69f59c", size = 662629, upload-time = "2026-06-17T18:29:51.728Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/a5/68cefae3a07f6d0093a490cf28ab604f14578f3e60205a2a2b2d5cd70af2/greenlet-3.5.2-cp315-cp315t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7fe6062b1f35534e1e8fb28dfed406cf4eeff3e0bca3a0d9f8ff69f20a4abb00", size = 660147, upload-time = "2026-06-17T17:39:35.068Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/6b/b9156d8397e4750220f54c7c5c34650f1e740a8d2f66eab9cfd1b7b53b69/greenlet-3.5.2-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:b4ac902af825cbac8e9b2fccab8122236fd2ba6c8b71a080116d2c2ec72671b1", size = 1621675, upload-time = "2026-06-17T18:22:18.873Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/e3/d3250f4fa01c211a93d04e34fded63187e648dbec17b9b1a14d388040593/greenlet-3.5.2-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:6f1e473c06ae8be00c9034c2bb10fa277b08a93287e3111c395b839f01d27e1f", size = 1680577, upload-time = "2026-06-17T17:40:14.055Z" },
+    { url = "https://files.pythonhosted.org/packages/55/ba/eaee8bda4419770d7096b5a009ebff0ab20a2a28cdd83c4b591bfdf36fa9/greenlet-3.5.2-cp315-cp315t-win_amd64.whl", hash = "sha256:3c2315045f9983e2e50d7e89d95405c21bddb8745f2da4487bc080ab3525f904", size = 243482, upload-time = "2026-06-17T17:37:34.741Z" },
+    { url = "https://files.pythonhosted.org/packages/37/45/f794a81c91e9942c61f9110bd1f9a38a0ea565eab57f8b08cd53d3131e48/greenlet-3.5.2-cp315-cp315t-win_arm64.whl", hash = "sha256:db548d5ab6c2a8ead82c013f875090d79b5d7d2b67fc513934ce6cf66492ad7f", size = 242062, upload-time = "2026-06-17T17:35:39.814Z" },
+]
+
 [[package]]
 name = "iniconfig"
 version = "2.3.0"
@@ -131,6 +186,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
 ]
 
+[[package]]
+name = "pymysql"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c9/bc/1c6a92f385940f727daeecf3bacaf186e03875dff57197801046c583bcf0/pymysql-1.2.0.tar.gz", hash = "sha256:6c7b17ca686988104d7426c27895b455cdeea3e9d3ceb1270f0c3704fead8c33", size = 49021, upload-time = "2026-05-19T08:26:22.302Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c4/bd/2534e130295c8cfd4f0a2e31623baab7502278f1e97bcfe61db75656a77f/pymysql-1.2.0-py3-none-any.whl", hash = "sha256:62169ce6d5510f08e140c5e7990ee884a9764024e4a9a27b2cc11f1099322ae0", size = 45716, upload-time = "2026-05-19T08:26:20.974Z" },
+]
+
 [[package]]
 name = "pytest"
 version = "9.0.3"
@@ -186,9 +250,50 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/2d/c7/c53e8dbff9c9dc4b7928773421ae294a5d28fcb8dcda1a089579d3a7e510/ruff-0.15.17-py3-none-win_arm64.whl", hash = "sha256:f3be1fbb34bcdfd146240d8fb92a709d4c2c8191348580a3c044ec60fa0b4456", size = 11355275, upload-time = "2026-06-11T17:54:43.635Z" },
 ]
 
+[[package]]
+name = "sqlalchemy"
+version = "2.0.51"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "greenlet", marker = "platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64'" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/02/f1/a7a892f18d4d224e6b26f706531eafccc41e37594d37d304786969ee13cb/sqlalchemy-2.0.51.tar.gz", hash = "sha256:804dccd8a4a6242c4e30ad961e540e18a588f6527202f2d6791b01845d59fdc9", size = 9912201, upload-time = "2026-06-15T15:41:20.012Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d5/70/e868bc5412acd101a8280f25c95f10eeae0771c4eb806b02491142810ee8/sqlalchemy-2.0.51-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7d78702b26ba1c18b2d0fb2ea940ba7f17a9581b42e8361ff93920ebbee1235a", size = 2160291, upload-time = "2026-06-15T16:08:48.918Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/1c/71ee0f8a6b9d7316a1ccd30430b4c62b6c2e36adc96017a4e3a72dce49d6/sqlalchemy-2.0.51-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581921d849d6e6f994d560389192955e80e2950e18fcdfe2ccea863e01158e6e", size = 3343835, upload-time = "2026-06-15T16:19:42.613Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/7c/7ab9f9aadc5944fdd06612484ed7918fe376ad871a5f50404dc1536e0194/sqlalchemy-2.0.51-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1d21ce524ab86c23046e992a5b81cb54c21079c6df6e78b8fc77d77cac70a6b9", size = 3358470, upload-time = "2026-06-15T16:26:38.011Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/7d/ff77169fee6186de145a7f2b87006c39638391130abbab2b1f63ac6ea583/sqlalchemy-2.0.51-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c5d98a2709840027f5a347c3af0a7c3d5f6c1ff93af2ca1c54494e23cba8f389", size = 3289874, upload-time = "2026-06-15T16:19:45.212Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/3b/6c505903710d781b55bc3141ee34a062bf9745a6b5bc7333305b9ed63b33/sqlalchemy-2.0.51-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1181256e0f16479691b5616d36375dc2620ad8332b25978763c3d206ad3f3f1d", size = 3321692, upload-time = "2026-06-15T16:26:39.747Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/b7/c5ffe50aa2f4d947c9250e1519d939260329a07fe6272edfccd784b3d007/sqlalchemy-2.0.51-cp312-cp312-win32.whl", hash = "sha256:9f380393be5abeb6815f68fd39271b95127173511b6706b0a630a9995d53f8f5", size = 2119674, upload-time = "2026-06-15T16:23:09.543Z" },
+    { url = "https://files.pythonhosted.org/packages/25/dc/46a65916af68a06ef6b972c6050ba4c8f97070fe3fb33097d34229d9bef6/sqlalchemy-2.0.51-cp312-cp312-win_amd64.whl", hash = "sha256:2cf39aabdf48e87c1c2c2ed6d20d33ffa0733b3071ce9c5f66357947dd009080", size = 2146670, upload-time = "2026-06-15T16:23:11.048Z" },
+    { url = "https://files.pythonhosted.org/packages/54/fe/a210d52fd1a90ecfae8a78e9d8b27e18d733d60818a8bf250ff690b75120/sqlalchemy-2.0.51-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7c2056838b6685b72fdb36c99996cf862753461a62f2e84f4196371d3b2d6a07", size = 2157184, upload-time = "2026-06-15T16:08:50.374Z" },
+    { url = "https://files.pythonhosted.org/packages/17/6b/2dce8369b199cb855110e056032f94a9f66dacc2237d3d39c115a86eac56/sqlalchemy-2.0.51-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:483b11bd46bf35fc14c52faf338b04300c9e6ce554bce9b11be85bfec3bc3195", size = 3284735, upload-time = "2026-06-15T16:19:46.934Z" },
+    { url = "https://files.pythonhosted.org/packages/53/ff/dbc495b8a14da840faffb353857a72d4190113cac33727906fb997047f0f/sqlalchemy-2.0.51-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1bed1ee8b01da6088210aa9412023326fb98a599ba502e6118308601dcbef77f", size = 3302756, upload-time = "2026-06-15T16:26:41.336Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/d5/fde8f4dddcf518ee15ab35a7c6a28acc32c8ba548d1d2aa451f96e6dbb0b/sqlalchemy-2.0.51-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:72ca54c952107ba5cd58854b67a5a6268631289d21651a1235396f3b98b47400", size = 3232055, upload-time = "2026-06-15T16:19:49.286Z" },
+    { url = "https://files.pythonhosted.org/packages/67/d1/43d3a0ac955a58601c24fa23038b1c55ee3a1ec02c0f96ebb1eae2bcf614/sqlalchemy-2.0.51-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b3e693d15533a45cd5906f0589f9c35090bef6ef45bf1e8195c424aa0ae06a8d", size = 3269850, upload-time = "2026-06-15T16:26:43.017Z" },
+    { url = "https://files.pythonhosted.org/packages/94/df/de669c7054cd47c4439ac34b1b2ee8b804a794791fbb10720e997a2c87c7/sqlalchemy-2.0.51-cp313-cp313-win32.whl", hash = "sha256:b93ab07b5292dbe7e6b8da89475275e7042744283921344b56105f3eeb0f828b", size = 2117721, upload-time = "2026-06-15T16:23:12.36Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/8a/403c51d064196bae20a0bc2476577f83a3f8dd299719a97417086b7f2ec5/sqlalchemy-2.0.51-cp313-cp313-win_amd64.whl", hash = "sha256:0f053118c30e53161857a953e4de667d90e274980dccbe5dd3829bbbeece72a5", size = 2143615, upload-time = "2026-06-15T16:23:13.906Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/49/a739be2e1d02a96a658eb71ab45d921c874249252358ad24a5bffdd02525/sqlalchemy-2.0.51-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6ea306caaae6bd5afd0a46050003c88f6bf33227377a49298c498c3cb88ff491", size = 2158999, upload-time = "2026-06-15T16:08:51.759Z" },
+    { url = "https://files.pythonhosted.org/packages/23/6b/2e0e38cf75c8780eca78d9b2e78164f8bcfd70125e5caa588ff5cbb9c9f4/sqlalchemy-2.0.51-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c45a496d6bc05dec41dcd4c3a2b183723f47473255c159cd80b503c8f246424d", size = 3282539, upload-time = "2026-06-15T16:19:51.065Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/a1/e77854cb5336fd37dc3c6ae3b71de242c98caac5725120be0b526b31cbd0/sqlalchemy-2.0.51-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4004ada0aafe8ae1991b2cd1d99c6d9146126e123bd6f883c260d974aa012e54", size = 3287545, upload-time = "2026-06-15T16:26:44.735Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/ab/9e17272fd4dac8df3b83c4fbe52b998a1c9d89a843c8c35ff29b74ff7364/sqlalchemy-2.0.51-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:0f6bcad487aee1c638d707235682fc96f741de00663619881ab235400d03289e", size = 3230929, upload-time = "2026-06-15T16:19:52.625Z" },
+    { url = "https://files.pythonhosted.org/packages/02/3c/52f408ea701781caee975606beccc48845f2aee8711ac29843d612c0306c/sqlalchemy-2.0.51-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:39a76529db6305693d8d4affa58ad5b5e2e18edd62daea628b29b97930b3513d", size = 3252888, upload-time = "2026-06-15T16:26:46.454Z" },
+    { url = "https://files.pythonhosted.org/packages/24/16/3efd2ee6bc4ca4693a30a1dd17a91b606cae15d517d2a4746611d9b73ce8/sqlalchemy-2.0.51-cp314-cp314-win32.whl", hash = "sha256:08a204d8b5638717c26a24df18fcf40af45a6b22e35b70b1d62f0113c2e278e8", size = 2120551, upload-time = "2026-06-15T16:23:15.629Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/78/55b12e70f45bccc40d9e483925c065027b3b98ea4cbbdf6f8c2546feaf6c/sqlalchemy-2.0.51-cp314-cp314-win_amd64.whl", hash = "sha256:96747bfbadb055466e5b46d572618170046b45ce5a4879167f50d70a5319a499", size = 2146318, upload-time = "2026-06-15T16:23:17.108Z" },
+    { url = "https://files.pythonhosted.org/packages/21/db/a9574ed40fed418924b1b1a3e54f47ee3963053b3d3d325a0d36b41f2c08/sqlalchemy-2.0.51-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e5ea1a213be1fcd5e49d9904c3b9939211ded90bc2a64e93f4c01963474285de", size = 2178920, upload-time = "2026-06-15T15:59:56.285Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/90/a1bb5c7cbba76b7bc1fbd586d0a5479a7bc9c27b4a8298f22ec9423b2bb3/sqlalchemy-2.0.51-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7c6b36ed71f41942bdcd2ad2522be46bfce09d5705be5640ecf19bbc7660e4b7", size = 3566534, upload-time = "2026-06-15T15:58:35.024Z" },
+    { url = "https://files.pythonhosted.org/packages/15/4b/481f1fed30e0e9e8dd24aecbb49f29eb57fe7657ece5cf06ee9b84bb97d8/sqlalchemy-2.0.51-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0c2c62877097e1a0db401fba5cb4debee33265e5b2a55c4ccb489c02c53b4f72", size = 3535844, upload-time = "2026-06-15T16:02:43.973Z" },
+    { url = "https://files.pythonhosted.org/packages/02/71/0aa64aeda645510af0a43f7d9ee70932f0d1dc4263aed34c50ee891d9df3/sqlalchemy-2.0.51-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0378d055e9e8cd6ce4d8dff683bdd3d7d413533c4ee51d67a2b1e0f9eacc0f23", size = 3475355, upload-time = "2026-06-15T15:58:36.592Z" },
+    { url = "https://files.pythonhosted.org/packages/05/db/6061db32316446135a3abae5f308d144ab988a34234726042da3e58b1c63/sqlalchemy-2.0.51-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6e46fc36029eff666391e0531e5387b62ce6c4f1d8e50b3fb3099eaca1b42522", size = 3486591, upload-time = "2026-06-15T16:02:45.346Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/c9/f14fdf71bb8957e0c7e39db69bbdf12b5c80f4ef775fdfa127bf4e0d6760/sqlalchemy-2.0.51-cp314-cp314t-win32.whl", hash = "sha256:9161cfc9efce70d1715f47d6ff40f79c6778c00d53be4fbc09d70301e4b83ba7", size = 2151313, upload-time = "2026-06-15T16:03:39.127Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/c6/673e618e6f4f297e126d9b56ea2f6478708f6c1af4e3223835c22e2c3697/sqlalchemy-2.0.51-cp314-cp314t-win_amd64.whl", hash = "sha256:159bb6ba32059f57ad7375a8f50d844dd2f19d14954ecf820cd33e20debd46b2", size = 2186280, upload-time = "2026-06-15T16:03:40.569Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/22/dbf013a12ec759e54a34a119e9e217435b3f71b2dd5c61a7ade0a25dae87/sqlalchemy-2.0.51-py3-none-any.whl", hash = "sha256:bb024d8b621d0be75f4f44ecc7c950450026e76d66dc8f791bb5331d7fed59d5", size = 1944334, upload-time = "2026-06-15T16:09:22.418Z" },
+]
+
 [[package]]
 name = "sqlqb"
-version = "0.1.2"
+version = "0.1.4"
 source = { editable = "." }
 
 [package.dev-dependencies]
@@ -197,6 +302,12 @@ dev = [
     { name = "pytest-cov" },
     { name = "ruff" },
 ]
+pymysql = [
+    { name = "pymysql" },
+]
+sqlalchemy = [
+    { name = "sqlalchemy" },
+]
 
 [package.metadata]
 
@@ -206,3 +317,14 @@ dev = [
     { name = "pytest-cov", specifier = ">=7.1.0" },
     { name = "ruff", specifier = ">=0.15.17" },
 ]
+pymysql = [{ name = "pymysql", specifier = ">=1.2.0" }]
+sqlalchemy = [{ name = "sqlalchemy", specifier = ">=2.0.51" }]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]