sqlqb 0.1.0__tar.gz → 0.1.2__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "sqlqb"
-version = "0.1.0"
+version = "0.1.2"
 description = "A simple sql query builder"
 readme = "README.md"
 authors = []

sqlqb-0.1.2/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.2/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.2/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.2/src/sqlqb/mysql/__init__.py

@@ -0,0 +1,82 @@
+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, *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):
+        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, 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):
+        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 Delete(self) -> Delete:
+        return Delete(self)
+
+    def Update(self, table: str) -> Update:
+        return Update(self, table)

{sqlqb-0.1.0 → sqlqb-0.1.2}/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.2/src/sqlqb/sqlite/__init__.py

@@ -0,0 +1,70 @@
+import sqlite3
+
+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, *args):
+        super().__init__(*args)
+        self.__connection = connection
+
+    def execute(self) -> sqlite3.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):
+        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, 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):
+        super().__init__()
+        self.__connection = connection
+
+    def execute(self) -> int:
+        return self.__connection.execute(self.sql, self.params).rowcount
+
+
+class Connection(sqlite3.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 Delete(self) -> Delete:
+        return Delete(self)
+
+    def Update(self, table: str) -> Update:
+        return Update(self, table)
+
+
+def connect(database, **kwargs) -> Connection:
+    return sqlite3.connect(database, factory=Connection, **kwargs)

sqlqb-0.1.2/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.2/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.2/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]

{sqlqb-0.1.0 → sqlqb-0.1.2}/tests/test_select.py

@@ -1,3 +1,5 @@
+import pytest
+
 from sqlqb import Select
 
 
@@ -30,6 +32,18 @@ class TestSelectBasic:
         q = Select("id").From("orders")
         assert "FROM orders" in q.sql
 
+    def test_columns_empty_raises(self):
+        with pytest.raises(ValueError):
+            Select().Columns()
+
+    def test_from_empty_raises(self):
+        with pytest.raises(ValueError):
+            Select().From("")
+
+    def test_from_blank_raises(self):
+        with pytest.raises(ValueError):
+            Select().From("   ")
+
     def test_method_chaining_returns_select(self):
         q = Select()
         assert q.From("t") is q
@@ -44,13 +58,13 @@ class TestSelectBasic:
 
 class TestWhere:
     def test_single_where(self):
-        q = Select("id").From("users").Where("id = %s", 1)
-        assert q.sql == "SELECT id FROM users WHERE id = %s"
+        q = Select("id").From("users").Where("id = ?", 1)
+        assert q.sql == "SELECT id FROM users WHERE id = ?"
         assert q.params == [1]
 
     def test_multiple_wheres_joined_with_and(self):
-        q = Select("id").From("users").Where("active = %s", True).Where("role = %s", "admin")
-        assert q.sql == "SELECT id FROM users WHERE active = %s AND role = %s"
+        q = Select("id").From("users").Where("active = ?", True).Where("role = ?", "admin")
+        assert q.sql == "SELECT id FROM users WHERE active = ? AND role = ?"
         assert q.params == [True, "admin"]
 
     def test_where_no_params(self):
@@ -59,7 +73,7 @@ class TestWhere:
         assert q.params == []
 
     def test_where_multiple_params(self):
-        q = Select().From("t").Where("a = %s AND b = %s", 1, 2)
+        q = Select().From("t").Where("a = ? AND b = ?", 1, 2)
         assert q.params == [1, 2]
 
     def test_no_where_clause_absent(self):
@@ -78,11 +92,11 @@ class TestJoin:
         assert "JOIN items i ON i.order_id = o.id" in q.sql
 
     def test_join_with_params(self):
-        q = Select("u.id").From("users u").Join("JOIN orders o ON o.user_id = u.id AND o.status = %s", "active")
+        q = Select("u.id").From("users u").Join("JOIN orders o ON o.user_id = u.id AND o.status = ?", "active")
         assert q.params == ["active"]
 
     def test_join_params_combined_with_where_params(self):
-        q = Select("u.id").From("users u").Join("JOIN orders o ON o.user_id = u.id AND o.type = %s", "sale").Where("u.active = %s", True)
+        q = Select("u.id").From("users u").Join("JOIN orders o ON o.user_id = u.id AND o.type = ?", "sale").Where("u.active = ?", True)
         assert q.params == ["sale", True]
 
     def test_no_join_absent(self):
@@ -103,6 +117,10 @@ class TestOrderBy:
         q = Select("id").From("users").OrderBy("name").OrderBy("created_at", "DESC")
         assert q.sql == "SELECT id FROM users ORDER BY name ASC, created_at DESC"
 
+    def test_invalid_direction_raises(self):
+        with pytest.raises(ValueError):
+            Select("id").From("users").OrderBy("id", "RANDOM")
+
     def test_no_order_by_absent(self):
         q = Select("id").From("users")
         assert "ORDER BY" not in q.sql
@@ -163,14 +181,14 @@ class TestParams:
         assert q.params == []
 
     def test_params_accumulate_across_joins_and_wheres(self):
-        q = Select("id").From("users").Join("JOIN t ON t.id = users.t_id AND t.x = %s", 42).Where("active = %s", True).Where("role IN (%s, %s)", "admin", "mod")
+        q = Select("id").From("users").Join("JOIN t ON t.id = users.t_id AND t.x = ?", 42).Where("active = ?", True).Where("role IN (?, ?)", "admin", "mod")
         assert q.params == [42, True, "admin", "mod"]
 
 
 class TestClauseOrdering:
     def test_full_query_clause_order(self):
-        sql = Select("u.id", "u.name").From("users u").Join("JOIN orders o ON o.user_id = u.id").Where("u.active = %s", True).GroupBy("u.id", "u.name").OrderBy("u.name").Limit(25).Offset(50).sql
-        assert sql == ("SELECT u.id, u.name FROM users u JOIN orders o ON o.user_id = u.id WHERE u.active = %s GROUP BY u.id, u.name ORDER BY u.name ASC LIMIT 25 OFFSET 50")
+        sql = Select("u.id", "u.name").From("users u").Join("JOIN orders o ON o.user_id = u.id").Where("u.active = ?", True).GroupBy("u.id", "u.name").OrderBy("u.name").Limit(25).Offset(50).sql
+        assert sql == ("SELECT u.id, u.name FROM users u JOIN orders o ON o.user_id = u.id WHERE u.active = ? GROUP BY u.id, u.name ORDER BY u.name ASC LIMIT 25 OFFSET 50")
 
     def test_group_by_before_order_by(self):
         sql = Select("a").From("t").OrderBy("a").GroupBy("a").sql

sqlqb-0.1.2/tests/test_sqlite.py

@@ -0,0 +1,112 @@
+import pytest
+
+from sqlqb import sqlite
+
+
+@pytest.fixture
+def conn():
+    c = sqlite.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()
+    return c
+
+
+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_where_with_param(self, conn):
+        rows = conn.Select("name").From("users").Where("age >= ?", 18).fetchall()
+        assert rows == [{"name": "Alice"}, {"name": "Carol"}]
+
+    def test_execute_returns_cursor(self, conn):
+        cursor = conn.Select("*").From("users").execute()
+        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()
+        )
+        assert rows == [{"name": "Alice"}, {"name": "Carol"}]
+
+    def test_limit(self, conn):
+        rows = conn.Select("id").From("users").Limit(2).fetchall()
+        assert rows == [{"id": 1}, {"id": 2}]
+
+
+class TestInsert:
+    def test_insert_returns_rowcount(self, conn):
+        count = conn.Insert().Into("users").Values(id=4, name="Dave", age=40).execute()
+        assert count == 1
+
+    def test_insert_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
+
+    def test_insert_multiple_rows_are_queryable(self, conn):
+        conn.Insert().Into("users").Values(id=4, name="Dave", age=40).Values(id=5, name="Eve", age=22).execute()
+        rows = conn.Select("name").From("users").Where("id = ?", 4).fetchall()
+        assert rows == [{"name": "Dave"}]
+
+
+class TestUpdate:
+    def test_update_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_affects_correct_rows_only(self, conn):
+        conn.Update("users").Set(age=99).Where("id = ?", 1).execute()
+        rows = conn.Select("age").From("users").fetchall()
+        assert rows == [{"age": 99}, {"age": 17}, {"age": 25}]
+
+    def test_update_no_where_affects_all(self, conn):
+        count = conn.Update("users").Set(age=0).execute()
+        assert count == 3
+
+
+class TestDelete:
+    def test_delete_returns_rowcount(self, conn):
+        count = conn.Delete().From("users").Where("id = ?", 1).execute()
+        assert count == 1
+
+    def test_delete_row_is_gone(self, conn):
+        conn.Delete().From("users").Where("id = ?", 1).execute()
+        row = conn.Select("*").From("users").Where("id = ?", 1).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 == []
+
+    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):
+            conn.Delete().From("users").Limit(2).execute()

sqlqb-0.1.2/tests/test_update.py

@@ -0,0 +1,100 @@
+import pytest
+
+from sqlqb import Update
+
+
+class TestUpdateBasic:
+    def test_single_column(self):
+        q = Update("users").Set(name="Alice")
+        assert q.sql == "UPDATE users SET name = ?"
+        assert q.params == ["Alice"]
+
+    def test_multiple_columns(self):
+        q = Update("users").Set(name="Alice", active=True)
+        assert q.sql == "UPDATE users SET name = ?, active = ?"
+        assert q.params == ["Alice", True]
+
+    def test_str_equals_sql(self):
+        q = Update("users").Set(name="Alice")
+        assert str(q) == q.sql
+
+    def test_empty_table_raises(self):
+        with pytest.raises(ValueError):
+            Update("")
+
+    def test_blank_table_raises(self):
+        with pytest.raises(ValueError):
+            Update("   ")
+
+    def test_no_set_sql_raises(self):
+        with pytest.raises(ValueError):
+            Update("users").sql
+
+    def test_empty_set_raises(self):
+        with pytest.raises(ValueError):
+            Update("users").Set()
+
+    def test_params_empty_before_set(self):
+        q = Update("users")
+        assert q.params == []
+
+    def test_chained_set_merges_columns(self):
+        q = Update("users").Set(name="Alice").Set(active=False)
+        assert "name = ?" in q.sql
+        assert "active = ?" in q.sql
+        assert q.params == ["Alice", False]
+
+    def test_chained_set_overwrites_same_column(self):
+        q = Update("users").Set(name="Alice").Set(name="Bob")
+        assert q.params == ["Bob"]
+
+    def test_various_value_types(self):
+        q = Update("t").Set(x=42, flag=True, score=3.14, label=None)
+        assert q.params == [42, True, 3.14, None]
+
+
+class TestUpdateWhere:
+    def test_single_where(self):
+        q = Update("users").Set(active=False).Where("id = ?", 1)
+        assert q.sql == "UPDATE users SET active = ? WHERE id = ?"
+        assert q.params == [False, 1]
+
+    def test_multiple_wheres_joined_with_and(self):
+        q = Update("users").Set(role="guest").Where("active = ?", False).Where("role = ?", "admin")
+        assert "WHERE active = ? AND role = ?" in q.sql
+        assert q.params == ["guest", False, "admin"]
+
+    def test_where_no_params(self):
+        q = Update("sessions").Set(expired=True).Where("token IS NOT NULL")
+        assert "WHERE token IS NOT NULL" in q.sql
+
+    def test_set_params_before_where_params(self):
+        q = Update("t").Set(x=1).Where("y = ?", 2)
+        assert q.params == [1, 2]
+
+    def test_no_where_absent(self):
+        q = Update("users").Set(active=True)
+        assert "WHERE" not in q.sql
+
+
+class TestUpdateLimit:
+    def test_limit(self):
+        q = Update("logs").Set(processed=True).Limit(100)
+        assert "LIMIT 100" in q.sql
+
+    def test_no_limit_absent(self):
+        q = Update("users").Set(active=True)
+        assert "LIMIT" not in q.sql
+
+
+class TestUpdateChaining:
+    def test_method_chaining_returns_update(self):
+        q = Update("t")
+        assert q.Set(x=1) is q
+        assert q.Where("1=1") is q
+        assert q.Limit(5) is q
+
+    def test_full_query(self):
+        q = Update("users").Set(role="admin", active=True).Where("id = ?", 42).Limit(1)
+        assert q.sql == "UPDATE users SET role = ?, active = ? WHERE id = ? LIMIT 1"
+        assert q.params == ["admin", True, 42]

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

@@ -188,7 +188,7 @@ wheels = [
 
 [[package]]
 name = "sqlqb"
-version = "0.1.0"
+version = "0.1.2"
 source = { editable = "." }
 
 [package.dev-dependencies]

sqlqb-0.1.0/src/sqlqb/__init__.py

@@ -1,3 +0,0 @@
-from .select import Select
-
-__all__ = ["Select"]