sqlqb 0.1.4__tar.gz → 0.2.1__tar.gz

{sqlqb-0.1.4 → sqlqb-0.2.1}/Makefile

@@ -14,7 +14,8 @@ clean:
 
 .PHONY: lint
 lint:
-	uv run ruff check .
+	uv run ruff check src/ tests/
+	uv run ruff format --check src/ tests/
 
 
 .PHONY: test

sqlqb-0.2.1/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.5
+Name: sqlqb
+Version: 0.2.1
+Summary: a simple sql query builder
+Requires-Python: >=3.12

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

@@ -1,16 +1,16 @@
 [project]
 name = "sqlqb"
-version = "0.1.4"
-description = "A simple sql query builder"
+dynamic = ["version"]
+description = "a simple sql query builder"
 readme = "README.md"
 authors = []
-requires-python = ">=3.12"
+requires-python = ">= 3.12"
 dependencies = []
 
 [dependency-groups]
 dev = [
-    "pytest>=9.0.3",
     "pytest-cov>=7.1.0",
+    "pytest>=9.0.3",
     "ruff>=0.15.17",
 ]
 pymysql = [
@@ -31,7 +31,9 @@ source = "vcs"
 testpaths = ["tests"]
 
 [tool.ruff]
-line-length = 999
+line-length = 320
 
 [tool.ruff.lint]
-ignore = ["E501"]  # E501 is the line-too-long rule
+ignore = [
+    "E501",  # E501 is the line-too-long rule
+]

{sqlqb-0.1.4 → sqlqb-0.2.1}/src/sqlqb/__init__.py

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

sqlqb-0.2.1/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.1}/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.1}/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.1}/src/sqlqb/sqlalchemy/__init__.py

@@ -3,22 +3,10 @@ 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 Delete as _Delete
 from sqlqb import Insert as _Insert
+from sqlqb import Select as _Select
 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):
@@ -27,16 +15,13 @@ class Select(_Select):
         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.1}/src/sqlqb/sqlite3/__init__.py

@@ -2,10 +2,10 @@ 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 Delete as _Delete
 from sqlqb import Insert as _Insert
+from sqlqb import Select as _Select
 from sqlqb import Update as _Update
-from sqlqb import Delete as _Delete
 
 
 class Select(_Select):
@@ -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.1/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.2.1/tests/test_delete.py

@@ -0,0 +1,62 @@
+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("").sql
+
+    def test_blank_table_raises(self):
+        with pytest.raises(ValueError):
+            _ = Delete().From("   ").sql
+
+    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 = :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 = :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_no_where_absent(self):
+        q = Delete().From("users")
+        assert "WHERE" 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
+
+    def test_full_query(self):
+        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.1}/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()
@@ -33,23 +33,23 @@ class TestInsertBasic:
 
     def test_no_table_raises(self):
         with pytest.raises(ValueError):
-            Insert().Values(name="Alice").sql
+            _ = Insert().Values(name="Alice").sql
 
     def test_no_values_raises(self):
         with pytest.raises(ValueError):
-            Insert().Into("users").sql
+            _ = Insert().Into("users").sql
 
     def test_empty_table_raises(self):
         with pytest.raises(ValueError):
-            Insert().Into("")
+            _ = Insert().Into("")
 
     def test_blank_table_raises(self):
         with pytest.raises(ValueError):
-            Insert().Into("   ")
+            _ = Insert().Into("   ")
 
     def test_empty_values_raises(self):
         with pytest.raises(ValueError):
-            Insert().Into("users").Values()
+            _ = Insert().Into("users").Values()
 
     def test_params_empty_before_values(self):
         q = Insert().Into("users")
@@ -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.1}/tests/test_pymysql.py

@@ -1,10 +1,11 @@
-import pytest
 from unittest.mock import MagicMock, patch
 
-from sqlqb import pymysql
-from sqlqb.pymysql import Select, Insert, Update, Delete, Connection
+import pytest
 from pymysql.cursors import DictCursor
 
+from sqlqb import pymysql
+from sqlqb.pymysql import Connection, Delete, Insert, Select, Update, _to_pymysql
+
 
 @pytest.fixture
 def mock_conn():
@@ -33,9 +34,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 +47,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 +93,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 +134,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 +158,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 +169,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 +190,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: