sqlqb 0.1.1__tar.gz → 0.1.3__tar.gz

{sqlqb-0.1.1 → sqlqb-0.1.3}/PKG-INFO

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

{sqlqb-0.1.1 → sqlqb-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlqb"
-version = "0.1.1"
+version = "0.1.3"
 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.3/src/sqlqb/__init__.py

@@ -0,0 +1,6 @@
+from .select import Select
+from .insert import Insert
+from .delete import Delete
+from .update import Update
+
+__all__ = ["Select", "Insert", "Delete", "Update"]

sqlqb-0.1.3/src/sqlqb/delete.py

@@ -0,0 +1,45 @@
+import io
+
+
+class Delete:
+    def __init__(self):
+        self.__table: str | None = None
+        self.__wheres: list[str] = []
+        self.__params: list = []
+        self.__limit: int | None = None
+
+    def From(self, table: str) -> "Delete":
+        if not table or not table.strip():
+            raise ValueError("error: table name must not be empty")
+        self.__table = table
+        return self
+
+    def Where(self, condition: str, *args) -> "Delete":
+        self.__wheres.append(condition)
+        self.__params += args
+        return self
+
+    def Limit(self, limit: int) -> "Delete":
+        self.__limit = limit
+        return self
+
+    @property
+    def params(self) -> list:
+        return self.__params
+
+    @property
+    def sql(self) -> str:
+        if not self.__table:
+            raise ValueError("error: no table specified")
+        sql = io.StringIO()
+        sql.write("DELETE FROM ")
+        sql.write(self.__table)
+        if self.__wheres:
+            sql.write(" WHERE ")
+            sql.write(" AND ".join(self.__wheres))
+        if self.__limit is not None:
+            sql.write(f" LIMIT {self.__limit}")
+        return sql.getvalue()
+
+    def __str__(self) -> str:
+        return self.sql

sqlqb-0.1.3/src/sqlqb/insert.py

@@ -0,0 +1,45 @@
+import io
+
+
+class Insert:
+    def __init__(self):
+        self.__table: str | None = None
+        self.__rows: list[dict] = []
+
+    def Into(self, table: str) -> "Insert":
+        if not table or not table.strip():
+            raise ValueError("error: table name must not be empty")
+        self.__table = table
+        return self
+
+    def Values(self, **kwargs) -> "Insert":
+        if not kwargs:
+            raise ValueError("error: specify at least one column value")
+        self.__rows.append(kwargs)
+        return self
+
+    @property
+    def params(self) -> list:
+        if not self.__rows:
+            return []
+        return [v for row in self.__rows for v in row.values()]
+
+    @property
+    def sql(self) -> str:
+        if not self.__table:
+            raise ValueError("error: no table specified")
+        if not self.__rows:
+            raise ValueError("error: no values specified")
+        columns = list(self.__rows[0].keys())
+        sql = io.StringIO()
+        sql.write("INSERT INTO ")
+        sql.write(self.__table)
+        sql.write(" (")
+        sql.write(", ".join(columns))
+        sql.write(") VALUES ")
+        placeholder = "(" + ", ".join(["?"] * len(columns)) + ")"
+        sql.write(", ".join([placeholder] * len(self.__rows)))
+        return sql.getvalue()
+
+    def __str__(self) -> str:
+        return self.sql

sqlqb-0.1.3/src/sqlqb/pymysql/__init__.py

@@ -0,0 +1,85 @@
+from pymysql.connections import Connection as _Connection
+from pymysql.cursors import DictCursor
+
+from sqlqb import Select as _Select
+from sqlqb import Insert as _Insert
+from sqlqb import Update as _Update
+from sqlqb import Delete as _Delete
+
+
+class Select(_Select):
+    def __init__(self, connection: _Connection, *args):
+        super().__init__(*args)
+        self.__connection = connection
+
+    def execute(self):
+        cursor = self.__connection.cursor()
+        cursor.execute(self.sql, self.params)
+        return cursor
+
+    def fetchone(self):
+        with self.__connection.cursor() as cursor:
+            cursor.execute(self.sql, self.params)
+            result = cursor.fetchone()
+        return result
+
+    def fetchall(self):
+        with self.__connection.cursor() as cursor:
+            cursor.execute(self.sql, self.params)
+            result = cursor.fetchall()
+        return result
+
+
+class Insert(_Insert):
+    def __init__(self, connection: _Connection):
+        super().__init__()
+        self.__connection = connection
+
+    def execute(self) -> int:
+        with self.__connection.cursor() as cursor:
+            cursor.execute(self.sql, self.params)
+            return cursor.rowcount
+
+
+class Update(_Update):
+    def __init__(self, connection: _Connection, table: str):
+        super().__init__(table)
+        self.__connection = connection
+
+    def execute(self) -> int:
+        with self.__connection.cursor() as cursor:
+            cursor.execute(self.sql, self.params)
+            return cursor.rowcount
+
+
+class Delete(_Delete):
+    def __init__(self, connection: _Connection):
+        super().__init__()
+        self.__connection = connection
+
+    def execute(self) -> int:
+        with self.__connection.cursor() as cursor:
+            cursor.execute(self.sql, self.params)
+            return cursor.rowcount
+
+
+class Connection(_Connection):
+    def __init__(self, *args, **kwargs):
+        if "cursorclass" not in kwargs:
+            kwargs["cursorclass"] = DictCursor
+        super().__init__(*args, **kwargs)
+
+    def Select(self, *args, **kwargs) -> Select:
+        return Select(self, *args, **kwargs)
+
+    def Insert(self) -> Insert:
+        return Insert(self)
+
+    def Update(self, table: str) -> Update:
+        return Update(self, table)
+
+    def Delete(self) -> Delete:
+        return Delete(self)
+
+
+connect = Connection

{sqlqb-0.1.1 → sqlqb-0.1.3}/src/sqlqb/select.py

@@ -2,22 +2,26 @@ import io
 
 
 class Select:
-    def __init__(self, *args):
-        self.__columns = list(args)
-        self.__table = None
-        self.__wheres = []
-        self.__params = []
-        self.__joins = []
-        self.__orderby = []
-        self.__groupby = []
-        self.__limit = None
-        self.__offset = None
+    def __init__(self, *args: str):
+        self.__columns: list[str] = list(args)
+        self.__table: str | None = None
+        self.__wheres: list[str] = []
+        self.__params: list = []
+        self.__joins: list[str] = []
+        self.__orderby: list[tuple[str, str]] = []
+        self.__groupby: list[str] = []
+        self.__limit: int | None = None
+        self.__offset: int | None = None
 
-    def Columns(self, *columns) -> "Select":
+    def Columns(self, *columns: str) -> "Select":
+        if not columns:
+            raise ValueError("error: specify at least one column")
         self.__columns = list(columns)
         return self
 
     def From(self, table: str) -> "Select":
+        if not table or not table.strip():
+            raise ValueError("error: table name must not be empty")
         self.__table = table
         return self
 
@@ -31,11 +35,13 @@ class Select:
         self.__params += args
         return self
 
-    def OrderBy(self, column: str, direction="ASC") -> "Select":
+    def OrderBy(self, column: str, direction: str = "ASC") -> "Select":
+        if direction not in ("ASC", "DESC"):
+            raise ValueError("error: invalid order by direction")
         self.__orderby.append((column, direction))
         return self
 
-    def GroupBy(self, *columns) -> "Select":
+    def GroupBy(self, *columns: str) -> "Select":
         self.__groupby += columns
         return self
 

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

@@ -0,0 +1,95 @@
+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) -> tuple[str, dict]:
+    """Replace ? placeholders with :p0, :p1, ... for SQLAlchemy text()."""
+    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.3/src/sqlqb/sqlite/__init__.py

@@ -0,0 +1,72 @@
+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
+from sqlqb import Update as _Update
+from sqlqb import Delete as _Delete
+
+
+class Select(_Select):
+    def __init__(self, connection: _Connection, *args):
+        super().__init__(*args)
+        self.__connection = connection
+
+    def execute(self) -> _Cursor:
+        return self.__connection.execute(self.sql, self.params)
+
+    def fetchone(self):
+        return self.execute().fetchone()
+
+    def fetchall(self) -> list:
+        return self.execute().fetchall()
+
+
+class Insert(_Insert):
+    def __init__(self, connection: _Connection):
+        super().__init__()
+        self.__connection = connection
+
+    def execute(self) -> int:
+        return self.__connection.execute(self.sql, self.params).rowcount
+
+
+class Update(_Update):
+    def __init__(self, connection: _Connection, table: str):
+        super().__init__(table)
+        self.__connection = connection
+
+    def execute(self) -> int:
+        return self.__connection.execute(self.sql, self.params).rowcount
+
+
+class Delete(_Delete):
+    def __init__(self, connection: _Connection):
+        super().__init__()
+        self.__connection = connection
+
+    def execute(self) -> int:
+        return self.__connection.execute(self.sql, self.params).rowcount
+
+
+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))
+
+    def Select(self, *args, **kwargs) -> Select:
+        return Select(self, *args, **kwargs)
+
+    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 connect(database, **kwargs) -> Connection:
+    return _connect(database, factory=Connection, **kwargs)

sqlqb-0.1.3/src/sqlqb/update.py

@@ -0,0 +1,52 @@
+import io
+
+
+class Update:
+    def __init__(self, table: str):
+        if not table or not table.strip():
+            raise ValueError("error: table name must not be empty")
+        self.__table = table
+        self.__sets: dict[str, object] = {}
+        self.__wheres: list[str] = []
+        self.__where_params: list = []
+        self.__limit: int | None = None
+
+    def Set(self, **kwargs) -> "Update":
+        if not kwargs:
+            raise ValueError("error: specify at least one column value")
+        self.__sets.update(kwargs)
+        return self
+
+    def Where(self, condition: str, *args) -> "Update":
+        self.__wheres.append(condition)
+        self.__where_params += args
+        return self
+
+    def Limit(self, limit: int) -> "Update":
+        self.__limit = limit
+        return self
+
+    @property
+    def params(self) -> list:
+        if not self.__sets:
+            return []
+        return list(self.__sets.values()) + self.__where_params
+
+    @property
+    def sql(self) -> str:
+        if not self.__sets:
+            raise ValueError("error: no SET values specified")
+        sql = io.StringIO()
+        sql.write("UPDATE ")
+        sql.write(self.__table)
+        sql.write(" SET ")
+        sql.write(", ".join([f"{col} = ?" for col in self.__sets]))
+        if self.__wheres:
+            sql.write(" WHERE ")
+            sql.write(" AND ".join(self.__wheres))
+        if self.__limit is not None:
+            sql.write(f" LIMIT {self.__limit}")
+        return sql.getvalue()
+
+    def __str__(self) -> str:
+        return self.sql

sqlqb-0.1.3/tests/test_delete.py

@@ -0,0 +1,81 @@
+import pytest
+
+from sqlqb import Delete
+
+
+class TestDeleteBasic:
+    def test_delete_all(self):
+        q = Delete().From("users")
+        assert q.sql == "DELETE FROM users"
+
+    def test_str_equals_sql(self):
+        q = Delete().From("users")
+        assert str(q) == q.sql
+
+    def test_no_table_raises(self):
+        with pytest.raises(ValueError):
+            Delete().sql
+
+    def test_empty_table_raises(self):
+        with pytest.raises(ValueError):
+            Delete().From("")
+
+    def test_blank_table_raises(self):
+        with pytest.raises(ValueError):
+            Delete().From("   ")
+
+    def test_params_empty_by_default(self):
+        q = Delete().From("users")
+        assert q.params == []
+
+
+class TestDeleteWhere:
+    def test_single_where(self):
+        q = Delete().From("users").Where("id = ?", 1)
+        assert q.sql == "DELETE FROM users WHERE id = ?"
+        assert q.params == [1]
+
+    def test_multiple_wheres_joined_with_and(self):
+        q = Delete().From("users").Where("active = ?", False).Where("role = ?", "guest")
+        assert q.sql == "DELETE FROM users WHERE active = ? AND role = ?"
+        assert q.params == [False, "guest"]
+
+    def test_where_no_params(self):
+        q = Delete().From("sessions").Where("expired_at IS NOT NULL")
+        assert q.sql == "DELETE FROM sessions WHERE expired_at IS NOT NULL"
+        assert q.params == []
+
+    def test_where_multiple_params(self):
+        q = Delete().From("t").Where("a = ? AND b = ?", 1, 2)
+        assert q.params == [1, 2]
+
+    def test_no_where_absent(self):
+        q = Delete().From("users")
+        assert "WHERE" not in q.sql
+
+
+class TestDeleteLimit:
+    def test_limit(self):
+        q = Delete().From("logs").Limit(100)
+        assert "LIMIT 100" in q.sql
+
+    def test_no_order_by_absent(self):
+        q = Delete().From("users")
+        assert "ORDER BY" not in q.sql
+
+    def test_no_limit_absent(self):
+        q = Delete().From("users")
+        assert "LIMIT" not in q.sql
+
+
+class TestDeleteChaining:
+    def test_method_chaining_returns_delete(self):
+        q = Delete()
+        assert q.From("t") is q
+        assert q.Where("1=1") is q
+        assert q.Limit(5) is q
+
+    def test_full_query(self):
+        q = Delete().From("logs").Where("level = ?", "debug").Limit(500)
+        assert q.sql == "DELETE FROM logs WHERE level = ? LIMIT 500"
+        assert q.params == ["debug"]

sqlqb-0.1.3/tests/test_insert.py

@@ -0,0 +1,60 @@
+import pytest
+
+from sqlqb import Insert
+
+
+class TestInsertBasic:
+    def test_single_row(self):
+        q = Insert().Into("users").Values(name="Alice", email="alice@example.com")
+        assert q.sql == "INSERT INTO users (name, email) VALUES (?, ?)"
+
+    def test_str_equals_sql(self):
+        q = Insert().Into("users").Values(name="Alice")
+        assert str(q) == q.sql
+
+    def test_params_single_row(self):
+        q = Insert().Into("users").Values(name="Alice", email="alice@example.com")
+        assert q.params == ["Alice", "alice@example.com"]
+
+    def test_multiple_rows(self):
+        q = Insert().Into("users").Values(name="Alice").Values(name="Bob")
+        assert q.sql == "INSERT INTO users (name) VALUES (?), (?)"
+        assert q.params == ["Alice", "Bob"]
+
+    def test_multiple_columns_multiple_rows(self):
+        q = Insert().Into("orders").Values(user_id=1, total=99).Values(user_id=2, total=50)
+        assert q.sql == "INSERT INTO orders (user_id, total) VALUES (?, ?), (?, ?)"
+        assert q.params == [1, 99, 2, 50]
+
+    def test_method_chaining_returns_insert(self):
+        q = Insert()
+        assert q.Into("t") is q
+        assert q.Values(x=1) is q
+
+    def test_no_table_raises(self):
+        with pytest.raises(ValueError):
+            Insert().Values(name="Alice").sql
+
+    def test_no_values_raises(self):
+        with pytest.raises(ValueError):
+            Insert().Into("users").sql
+
+    def test_empty_table_raises(self):
+        with pytest.raises(ValueError):
+            Insert().Into("")
+
+    def test_blank_table_raises(self):
+        with pytest.raises(ValueError):
+            Insert().Into("   ")
+
+    def test_empty_values_raises(self):
+        with pytest.raises(ValueError):
+            Insert().Into("users").Values()
+
+    def test_params_empty_before_values(self):
+        q = Insert().Into("users")
+        assert q.params == []
+
+    def test_various_value_types(self):
+        q = Insert().Into("events").Values(user_id=42, active=True, score=3.14, label=None)
+        assert q.params == [42, True, 3.14, None]