sqlqb 0.1.4__tar.gz → 0.2.0__tar.gz

sqlqb-0.2.0/.claude/settings.local.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(python -m pytest tests/ -v)"
+    ]
+  }
+}

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

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

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

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

sqlqb-0.2.0/src/sqlqb/delete.py

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

{sqlqb-0.1.4 → sqlqb-0.2.0}/src/sqlqb/insert.py

@@ -4,7 +4,7 @@ import io
 class Insert:
     def __init__(self):
         self.__table: str | None = None
-        self.__rows: list[dict] = []
+        self.__values: list[dict] = []
 
     def Into(self, table: str) -> "Insert":
         if not table or not table.strip():
@@ -15,30 +15,28 @@ class Insert:
     def Values(self, **kwargs) -> "Insert":
         if not kwargs:
             raise ValueError("error: specify at least one column value")
-        self.__rows.append(kwargs)
+        self.__values.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()]
+        return self.__values
 
     @property
     def sql(self) -> str:
         if not self.__table:
             raise ValueError("error: no table specified")
-        if not self.__rows:
+        if not self.__values:
             raise ValueError("error: no values specified")
-        columns = list(self.__rows[0].keys())
+        columns = self.__values[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)))
+        sql.write(") VALUES (")
+        sql.write(", ".join([f":{column}" for column in columns]))  # TODO this assumes :style parameters
+        sql.write(")")
         return sql.getvalue()
 
     def __str__(self) -> str:

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

@@ -3,21 +3,20 @@ import io
 
 class Select:
     def __init__(self, *args: str):
-        self.__columns: list[str] = list(args)
+        self.__columns: tuple[str] = args
         self.__table: str | None = None
-        self.__wheres: list[str] = []
-        self.__params: list = []
-        self.__named_params: dict = {}
         self.__joins: list[str] = []
+        self.__wheres: list[str] = []
         self.__orderby: list[tuple[str, str]] = []
         self.__groupby: list[str] = []
         self.__limit: int | None = None
         self.__offset: int | None = None
+        self.__params: dict = {}
 
     def Columns(self, *columns: str) -> "Select":
         if not columns:
             raise ValueError("error: specify at least one column")
-        self.__columns = list(columns)
+        self.__columns = columns
         return self
 
     def From(self, table: str) -> "Select":
@@ -26,32 +25,14 @@ class Select:
         self.__table = table
         return self
 
-    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")
+    def Join(self, join: str, **kwargs) -> "Select":
         self.__joins.append(join)
-        if kwargs:
-            self.__named_params.update(kwargs)
-        else:
-            self.__params += list(args)
+        self.__params.update(kwargs)
         return self
 
-    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")
+    def Where(self, condition: str, **kwargs) -> "Select":
         self.__wheres.append(condition)
-        if kwargs:
-            self.__named_params.update(kwargs)
-        else:
-            self.__params += list(args)
+        self.__params.update(kwargs)
         return self
 
     def OrderBy(self, column: str, direction: str = "ASC") -> "Select":
@@ -73,19 +54,18 @@ class Select:
         return self
 
     @property
-    def params(self) -> list | dict:
-        if self.__named_params:
-            return self.__named_params
+    def params(self) -> dict:
         return self.__params
 
     @property
     def sql(self) -> str:
+        if not self.__table or not str(self.__table).strip():
+            raise ValueError("error: table name must not be empty")
         sql = io.StringIO()
         sql.write("SELECT ")
         sql.write(", ".join(self.__columns or "*"))
-        if self.__table:
-            sql.write(" FROM ")
-            sql.write(self.__table)
+        sql.write(" FROM ")
+        sql.write(self.__table)
         if self.__joins:
             sql.write(" ")
             sql.write(" ".join(self.__joins))

{sqlqb-0.1.4 → sqlqb-0.2.0}/src/sqlqb/sqlalchemy/__init__.py

@@ -9,34 +9,19 @@ 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)
+        return self.__connection.execute(text(self.sql), self.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()]
 
 
@@ -46,8 +31,7 @@ class Insert(_Insert):
         self.__connection = connection
 
     def execute(self) -> int:
-        sql, params = _bind(self.sql, self.params)
-        return self.__connection.execute(text(sql), params).rowcount
+        return self.__connection.execute(text(self.sql), self.params).rowcount
 
 
 class Update(_Update):
@@ -56,8 +40,7 @@ class Update(_Update):
         self.__connection = connection
 
     def execute(self) -> int:
-        sql, params = _bind(self.sql, self.params)
-        return self.__connection.execute(text(sql), params).rowcount
+        return self.__connection.execute(text(self.sql), self.params).rowcount
 
 
 class Delete(_Delete):
@@ -66,8 +49,7 @@ class Delete(_Delete):
         self.__connection = connection
 
     def execute(self) -> int:
-        sql, params = _bind(self.sql, self.params)
-        return self.__connection.execute(text(sql), params).rowcount
+        return self.__connection.execute(text(self.sql), self.params).rowcount
 
 
 class Connection(_Connection):

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

@@ -29,7 +29,12 @@ class Insert(_Insert):
         self.__connection = connection
 
     def execute(self) -> int:
-        return self.__connection.execute(self.sql, self.params).rowcount
+        if len(self.params) == 1:
+            return self.__connection.execute(self.sql, self.params[0]).rowcount
+        return self.__connection.executemany(self.sql, self.params).rowcount
+
+    def executemany(self) -> int:
+        return self.execute()
 
 
 class Update(_Update):

sqlqb-0.2.0/src/sqlqb/update.py

@@ -0,0 +1,43 @@
+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.__params: dict[str, object] = {}
+
+    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, **kwargs) -> "Update":
+        self.__wheres.append(condition)
+        self.__params.update(kwargs)
+        return self
+
+    @property
+    def params(self) -> dict:
+        return self.__sets | self.__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} = :{col}" for col in self.__sets]))
+        if self.__wheres:
+            sql.write(" WHERE ")
+            sql.write(" AND ".join(self.__wheres))
+        return sql.getvalue()
+
+    def __str__(self) -> str:
+        return self.sql

{sqlqb-0.1.4 → sqlqb-0.2.0}/tests/test_delete.py

@@ -18,64 +18,45 @@ class TestDeleteBasic:
 
     def test_empty_table_raises(self):
         with pytest.raises(ValueError):
-            Delete().From("")
+            Delete().From("").sql
 
     def test_blank_table_raises(self):
         with pytest.raises(ValueError):
-            Delete().From("   ")
+            Delete().From("   ").sql
 
     def test_params_empty_by_default(self):
         q = Delete().From("users")
-        assert q.params == []
+        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]
+        q = Delete().From("users").Where("id = :id", id=1)
+        assert q.sql == "DELETE FROM users WHERE id = :id"
+        assert q.params == {"id": 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"]
+        q = Delete().From("users").Where("active = :active", active=False).Where("role = :role", role="guest")
+        assert q.sql == "DELETE FROM users WHERE active = :active AND role = :role"
+        assert q.params == {"active": False, "role": "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]
+        assert q.params == {}
 
     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"]
+        q = Delete().From("logs").Where("level = :level", level="debug")
+        assert q.sql == "DELETE FROM logs WHERE level = :level"
+        assert q.params == {"level": "debug"}

{sqlqb-0.1.4 → sqlqb-0.2.0}/tests/test_insert.py

@@ -6,7 +6,7 @@ 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 (?, ?)"
+        assert q.sql == "INSERT INTO users (name, email) VALUES (:name, :email)"
 
     def test_str_equals_sql(self):
         q = Insert().Into("users").Values(name="Alice")
@@ -14,17 +14,17 @@ class TestInsertBasic:
 
     def test_params_single_row(self):
         q = Insert().Into("users").Values(name="Alice", email="alice@example.com")
-        assert q.params == ["Alice", "alice@example.com"]
+        assert q.params == [{"name": "Alice", "email": "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"]
+        assert q.sql == "INSERT INTO users (name) VALUES (:name)"
+        assert q.params == [{"name": "Alice"}, {"name": "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]
+        assert q.sql == "INSERT INTO orders (user_id, total) VALUES (:user_id, :total)"
+        assert q.params == [{"user_id": 1, "total": 99}, {"user_id": 2, "total": 50}]
 
     def test_method_chaining_returns_insert(self):
         q = Insert()
@@ -57,4 +57,4 @@ class TestInsertBasic:
 
     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]
+        assert q.params == [{"user_id": 42, "active": True, "score": 3.14, "label": None}]

{sqlqb-0.1.4 → sqlqb-0.2.0}/tests/test_pymysql.py

@@ -2,7 +2,7 @@ import pytest
 from unittest.mock import MagicMock, patch
 
 from sqlqb import pymysql
-from sqlqb.pymysql import Select, Insert, Update, Delete, Connection
+from sqlqb.pymysql import Select, Insert, Update, Delete, Connection, _to_pymysql
 from pymysql.cursors import DictCursor
 
 
@@ -33,9 +33,10 @@ class TestSelect:
 
     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 = Select(conn, "name").From("users").Where("id = :id", id=1)
         q.execute()
-        cursor.execute.assert_called_once_with(q.sql, q.params)
+        expected_sql, expected_params = _to_pymysql(q.sql, q.params)
+        cursor.execute.assert_called_once_with(expected_sql, expected_params)
 
     def test_execute_does_not_use_context_manager(self, mock_conn):
         conn, cursor = mock_conn
@@ -45,20 +46,21 @@ class TestSelect:
     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()
+        result = Select(conn, "id", "name").From("users").Where("id = :id", 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()
+        result = Select(conn, "id").From("users").Where("id = :id", 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 = Select(conn, "name").From("users").Where("id = :id", id=1)
         q.fetchone()
-        cursor.execute.assert_called_once_with(q.sql, q.params)
+        expected_sql, expected_params = _to_pymysql(q.sql, q.params)
+        cursor.execute.assert_called_once_with(expected_sql, expected_params)
 
     def test_fetchone_uses_context_manager(self, mock_conn):
         conn, cursor = mock_conn
@@ -90,14 +92,15 @@ class TestSelect:
 
     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 = Select(conn, "name").From("users").Where("age > :age", age=18).Where("active = :active", active=True)
         q.fetchall()
-        cursor.execute.assert_called_once_with(q.sql, [18, True])
+        expected_sql, expected_params = _to_pymysql(q.sql, q.params)
+        cursor.execute.assert_called_once_with(expected_sql, expected_params)
 
     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()
+        result = Select(conn, "name").From("users").Where("age >= :age", age=18).OrderBy("name").Limit(1).fetchall()
         assert result == [{"name": "Alice"}]
 
 
@@ -130,14 +133,15 @@ 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()
+        count = Update(conn, "users").Set(name="Alice").Where("id = :id", 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 = Update(conn, "users").Set(name="Alice").Where("id = :id", id=1)
         q.execute()
-        cursor.execute.assert_called_once_with(q.sql, q.params)
+        expected_sql, expected_params = _to_pymysql(q.sql, q.params)
+        cursor.execute.assert_called_once_with(expected_sql, expected_params)
 
     def test_execute_uses_context_manager(self, mock_conn):
         conn, cursor = mock_conn
@@ -153,9 +157,10 @@ class TestUpdate:
     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)
+        q = Update(conn, "users").Set(name="Bob", age=20).Where("id = :id", id=2)
         count = q.execute()
-        cursor.execute.assert_called_once_with(q.sql, q.params)
+        expected_sql, expected_params = _to_pymysql(q.sql, q.params)
+        cursor.execute.assert_called_once_with(expected_sql, expected_params)
         assert count == 1
 
 
@@ -163,18 +168,19 @@ 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()
+        count = Delete(conn).From("users").Where("id = :id", 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 = Delete(conn).From("users").Where("id = :id", id=1)
         q.execute()
-        cursor.execute.assert_called_once_with(q.sql, q.params)
+        expected_sql, expected_params = _to_pymysql(q.sql, q.params)
+        cursor.execute.assert_called_once_with(expected_sql, expected_params)
 
     def test_execute_uses_context_manager(self, mock_conn):
         conn, cursor = mock_conn
-        Delete(conn).From("users").Where("id = ?", 1).execute()
+        Delete(conn).From("users").Where("id = :id", id=1).execute()
         cursor.__enter__.assert_called_once()
 
     def test_execute_no_where_returns_all_rowcount(self, mock_conn):
@@ -183,13 +189,20 @@ class TestDelete:
         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 TestToPymysql:
+    def test_dict_params_converts_placeholders(self):
+        sql, params = _to_pymysql(
+            "SELECT * FROM t WHERE id = :id AND name = :name",
+            {"id": 1, "name": "Alice"},
+        )
+        assert sql == "SELECT * FROM t WHERE id = %(id)s AND name = %(name)s"
+        assert params == {"id": 1, "name": "Alice"}
+
+    def test_dict_params_single_placeholder(self):
+        sql, params = _to_pymysql("DELETE FROM t WHERE id = :id", {"id": 42})
+        assert sql == "DELETE FROM t WHERE id = %(id)s"
+        assert params == {"id": 42}
 
 
 class TestConnection:

{sqlqb-0.1.4 → sqlqb-0.2.0}/tests/test_select.py

@@ -32,6 +32,10 @@ class TestSelectBasic:
         q = Select("id").From("orders")
         assert "FROM orders" in q.sql
 
+    def test_table_empty_raises(self):
+        with pytest.raises(ValueError):
+            Select("1").sql
+
     def test_columns_empty_raises(self):
         with pytest.raises(ValueError):
             Select().Columns()
@@ -58,23 +62,19 @@ class TestSelectBasic:
 
 class TestWhere:
     def test_single_where(self):
-        q = Select("id").From("users").Where("id = ?", 1)
-        assert q.sql == "SELECT id FROM users WHERE id = ?"
-        assert q.params == [1]
+        q = Select("id").From("users").Where("id = :id", id=1)
+        assert q.sql == "SELECT id FROM users WHERE id = :id"
+        assert q.params == {"id": 1}
 
     def test_multiple_wheres_joined_with_and(self):
-        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"]
+        q = Select("id").From("users").Where("active = :active", active=True).Where("role = :role", role="admin")
+        assert q.sql == "SELECT id FROM users WHERE active = :active AND role = :role"
+        assert q.params == {"active": True, "role": "admin"}
 
     def test_where_no_params(self):
         q = Select("id").From("users").Where("deleted_at IS NULL")
         assert "WHERE deleted_at IS NULL" in q.sql
-        assert q.params == []
-
-    def test_where_multiple_params(self):
-        q = Select().From("t").Where("a = ? AND b = ?", 1, 2)
-        assert q.params == [1, 2]
+        assert q.params == {}
 
     def test_no_where_clause_absent(self):
         q = Select("id").From("users")
@@ -92,12 +92,17 @@ 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 = ?", "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 = ?", "sale").Where("u.active = ?", True)
-        assert q.params == ["sale", True]
+        q = Select("u.id").From("users u").Join("JOIN orders o ON o.user_id = u.id AND o.status = :status", status="active")
+        assert q.params == {"status": "active"}
+
+    def test_join_and_where_params(self):
+        q = (
+            Select("u.id")
+            .From("users u")
+            .Join("JOIN orders o ON o.user_id = u.id AND o.type = :type", type="sale")
+            .Where("u.active = :active", active=True)
+        )
+        assert q.params == {"type": "sale", "active": True}
 
     def test_no_join_absent(self):
         q = Select("id").From("users")
@@ -178,17 +183,33 @@ class TestLimitOffset:
 class TestParams:
     def test_params_empty_by_default(self):
         q = Select("id").From("users")
-        assert q.params == []
+        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 = ?", 42).Where("active = ?", True).Where("role IN (?, ?)", "admin", "mod")
-        assert q.params == [42, True, "admin", "mod"]
+        q = (
+            Select("id")
+            .From("users")
+            .Join("JOIN t ON t.id = users.t_id AND t.x = :x", x=42)
+            .Where("active = :active", active=True)
+            .Where("role = :role", role="admin")
+        )
+        assert q.params == {"x": 42, "active": True, "role": "admin"}
 
 
 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 = ?", 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")
+        sql = (
+            Select("u.id", "u.name")
+            .From("users u")
+            .Join("JOIN orders o ON o.user_id = u.id")
+            .Where("u.active = :active", 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 = :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.4 → sqlqb-0.2.0}/tests/test_sqlalchemy.py

@@ -107,23 +107,23 @@ class TestSelect:
         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()
+        row = conn.Select("name").From("users").Where("id = :id", 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()
+        row = conn.Select("name").From("users").Where("id = :id", 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()
+        rows = conn.Select("name").From("users").Where("id = :id", id=999).fetchall()
         assert rows == []
 
     def test_where_single_param(self, conn):
-        rows = conn.Select("name").From("users").Where("age >= ?", 18).fetchall()
+        rows = conn.Select("name").From("users").Where("age >= :age", 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()
+        rows = conn.Select("name").From("users").Where("age >= :min_age", min_age=18).Where("age <= :max_age", max_age=29).fetchall()
         assert rows == [{"name": "Carol"}]
 
     def test_order_by_asc(self, conn):
@@ -148,7 +148,7 @@ class TestSelect:
         assert type(rows[0]) is dict
 
     def test_fetchone_returns_plain_dict(self, conn):
-        row = conn.Select("id").From("users").Where("id = ?", 1).fetchone()
+        row = conn.Select("id").From("users").Where("id = :id", id=1).fetchone()
         assert type(row) is dict
 
 
@@ -164,7 +164,7 @@ class TestInsert:
 
     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()
+        row = conn.Select("name").From("users").Where("id = :id", id=4).fetchone()
         assert row == {"name": "Dave"}
 
     def test_insert_multiple_rows(self, conn):
@@ -179,17 +179,17 @@ class TestInsert:
 
 class TestUpdate:
     def test_execute_returns_rowcount(self, conn):
-        count = conn.Update("users").Set(name="Alicia").Where("id = ?", 1).execute()
+        count = conn.Update("users").Set(name="Alicia").Where("id = :id", 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()
+        conn.Update("users").Set(name="Alicia").Where("id = :id", id=1).execute()
+        row = conn.Select("name").From("users").Where("id = :id", 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()
+        conn.Update("users").Set(name="Bobby", age=18).Where("id = :id", id=2).execute()
+        row = conn.Select("name", "age").From("users").Where("id = :id", id=2).fetchone()
         assert row == {"name": "Bobby", "age": 18}
 
     def test_update_no_where_affects_all(self, conn):
@@ -197,7 +197,7 @@ class TestUpdate:
         assert count == 3
 
     def test_update_affects_correct_rows_only(self, conn):
-        conn.Update("users").Set(age=99).Where("id = ?", 1).execute()
+        conn.Update("users").Set(age=99).Where("id = :id", 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}]
 
@@ -210,13 +210,13 @@ class TestUpdate:
 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()
+        count = conn.Delete().From("users").Where("id = :id", 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()
+        conn.Delete().From("users").Where("id = :id", id=4).execute()
+        row = conn.Select("*").From("users").Where("id = :id", id=4).fetchone()
         assert row is None
 
     def test_delete_no_where_clears_table(self, conn):

{sqlqb-0.1.4 → sqlqb-0.2.0}/tests/test_sqlite3.py

@@ -7,7 +7,10 @@ from sqlqb import sqlite3
 def conn():
     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.executemany(
+        "INSERT INTO users VALUES (:id, :name, :age)",
+        [{"id": 1, "name": "Alice", "age": 30}, {"id": 2, "name": "Bob", "age": 17}, {"id": 3, "name": "Carol", "age": 25}],
+    )
     c.commit()
     return c
 
@@ -18,11 +21,11 @@ class TestSelect:
         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()
+        row = conn.Select("name").From("users").Where("id = :id", id=1).fetchone()
         assert row == {"name": "Alice"}
 
     def test_where_with_param(self, conn):
-        rows = conn.Select("name").From("users").Where("age >= ?", 18).fetchall()
+        rows = conn.Select("name").From("users").Where("age >= :age", age=18).fetchall()
         assert rows == [{"name": "Alice"}, {"name": "Carol"}]
 
     def test_execute_returns_cursor(self, conn):
@@ -30,7 +33,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 >= :age", age=18).OrderBy("name").fetchall()
         assert rows == [{"name": "Alice"}, {"name": "Carol"}]
 
     def test_limit(self, conn):
@@ -38,14 +41,16 @@ class TestSelect:
         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()
+        conn.Insert().Into("users").Values(id=4, name="Dave", age=40).executemany()
+        row = conn.Select("name").From("users").Where("id = :id", id=4).fetchone()
         assert row == {"name": "Dave"}
 
     def test_insert_multiple_rows(self, conn):
@@ -54,27 +59,34 @@ class TestInsert:
 
     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()
+        rows = conn.Select("name").From("users").Where("id = :id", id=4).fetchall()
         assert rows == [{"name": "Dave"}]
 
+    def test_executemany_all_rows_persisted(self, conn):
+        conn.Insert().Into("users").Values(id=4, name="Dave", age=40).Values(id=5, name="Eve", age=22).Values(id=6, name="Frank", age=35).execute()
+        rows = conn.Select("id", "name", "age").From("users").OrderBy("id").fetchall()
+        assert {"id": 4, "name": "Dave", "age": 40} in rows
+        assert {"id": 5, "name": "Eve", "age": 22} in rows
+        assert {"id": 6, "name": "Frank", "age": 35} in rows
+
 
 class TestUpdate:
     def test_update_returns_rowcount(self, conn):
-        count = conn.Update("users").Set(name="Alicia").Where("id = ?", 1).execute()
+        count = conn.Update("users").Set(name="Alicia").Where("id = :id", 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()
+        conn.Update("users").Set(name="Alicia").Where("id = :id", id=1).execute()
+        row = conn.Select("name").From("users").Where("id = :id", 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()
+        conn.Update("users").Set(name="Bobby", age=18).Where("id = :id", id=2).execute()
+        row = conn.Select("name", "age").From("users").Where("id = :id", 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()
+        conn.Update("users").Set(age=99).Where("id = :id", id=1).execute()
         rows = conn.Select("age").From("users").fetchall()
         assert rows == [{"age": 99}, {"age": 17}, {"age": 25}]
 
@@ -85,12 +97,12 @@ class TestUpdate:
 
 class TestDelete:
     def test_delete_returns_rowcount(self, conn):
-        count = conn.Delete().From("users").Where("id = ?", 1).execute()
+        count = conn.Delete().From("users").Where("id = :id", 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()
+        conn.Delete().From("users").Where("id = :id", id=1).execute()
+        row = conn.Select("*").From("users").Where("id = :id", id=1).fetchone()
         assert row is None
 
     def test_delete_no_where_clears_table(self, conn):
@@ -98,10 +110,3 @@ class TestDelete:
         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 as stdlib_sqlite3
-
-        with pytest.raises(stdlib_sqlite3.OperationalError):
-            conn.Delete().From("users").Limit(2).execute()

{sqlqb-0.1.4 → sqlqb-0.2.0}/tests/test_update.py

@@ -6,13 +6,13 @@ 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"]
+        assert q.sql == "UPDATE users SET name = :name"
+        assert q.params == {"name": "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]
+        assert q.sql == "UPDATE users SET name = :name, active = :active"
+        assert q.params == {"name": "Alice", "active": True}
 
     def test_str_equals_sql(self):
         q = Update("users").Set(name="Alice")
@@ -36,65 +36,54 @@ class TestUpdateBasic:
 
     def test_params_empty_before_set(self):
         q = Update("users")
-        assert q.params == []
+        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]
+        assert "name = :name" in q.sql
+        assert "active = :active" in q.sql
+        assert q.params == {"name": "Alice", "active": False}
 
     def test_chained_set_overwrites_same_column(self):
         q = Update("users").Set(name="Alice").Set(name="Bob")
-        assert q.params == ["Bob"]
+        assert q.params == {"name": "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]
+        assert q.params == {"x": 42, "flag": True, "score": 3.14, "label": 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]
+        q = Update("users").Set(active=False).Where("id = :id", id=1)
+        assert q.sql == "UPDATE users SET active = :active WHERE id = :id"
+        assert q.params == {"active": False, "id": 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"]
+        q = Update("users").Set(status="inactive").Where("active = :active", active=False).Where("role = :role", role="admin")
+        assert "WHERE active = :active AND role = :role" in q.sql
+        assert q.params == {"status": "inactive", "active": False, "role": "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]
+        q = Update("t").Set(x=1).Where("y = :y", y=2)
+        assert q.params == {"x": 1, "y": 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]
+        q = Update("users").Set(role="admin", active=True).Where("id = :id", id=42)
+        assert q.sql == "UPDATE users SET role = :role, active = :active WHERE id = :id"
+        assert q.params == {"role": "admin", "active": True, "id": 42}

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

@@ -293,7 +293,7 @@ wheels = [
 
 [[package]]
 name = "sqlqb"
-version = "0.1.4"
+version = "0.2.0"
 source = { editable = "." }
 
 [package.dev-dependencies]

sqlqb-0.1.4/src/sqlqb/delete.py

@@ -1,57 +0,0 @@
-import io
-
-
-class Delete:
-    def __init__(self):
-        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":
-        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, **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)
-        if kwargs:
-            self.__named_params.update(kwargs)
-        else:
-            self.__params += list(args)
-        return self
-
-    def Limit(self, limit: int) -> "Delete":
-        self.__limit = limit
-        return self
-
-    @property
-    def params(self) -> list | dict:
-        if self.__named_params:
-            return self.__named_params
-        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.4/src/sqlqb/update.py

@@ -1,69 +0,0 @@
-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.__where_named_params: dict = {}
-        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, **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)
-        if kwargs:
-            self.__where_named_params.update(kwargs)
-        else:
-            self.__where_params += list(args)
-        return self
-
-    def Limit(self, limit: int) -> "Update":
-        self.__limit = limit
-        return self
-
-    @property
-    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
-    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 ")
-        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))
-        if self.__limit is not None:
-            sql.write(f" LIMIT {self.__limit}")
-        return sql.getvalue()
-
-    def __str__(self) -> str:
-        return self.sql