Merge branch 'main' of github.com:qaspen-python/psqlpy

Author: chandr-andr

Cargo.lock

@@ -264,6 +264,63 @@ async def main() -> None:
     await transaction.rollback()
 ```
 
+### Transaction execute many
+
+You can execute one statement with multiple pararmeters.
+The query will be executed with all parameters or will not be executed at all.
+
+```python
+from typing import Any
+
+from psqlpy import PSQLPool, IsolationLevel
+
+
+db_pool = PSQLPool()
+
+async def main() -> None:
+    await db_pool.startup()
+
+    connection = await db_pool.connection()
+    transaction = connection.transaction(
+        isolation_level=IsolationLevel.Serializable,
+    )
+
+    await transaction.begin()
+    await transaction.execute_many(
+        "INSERT INTO users VALUES ($1)",
+        [["first-data"], ["second-data"], ["third-data"]],
+    )
+    await transaction.commit()
+```
+
+### Transaction fetch row
+
+You can fetch first row.
+
+```python
+from typing import Any
+
+from psqlpy import PSQLPool, IsolationLevel
+
+
+db_pool = PSQLPool()
+
+async def main() -> None:
+    await db_pool.startup()
+
+    connection = await db_pool.connection()
+    transaction = connection.transaction(
+        isolation_level=IsolationLevel.Serializable,
+    )
+
+    await transaction.begin()
+    first_row = await transaction.fetch_row(
+        "SELECT * FROM users WHERE user_id = $1",
+        ["user-id"],
+    )
+    first_row_result = first_row.result()  # This will be a dict.
+```
+
 ### Transaction ROLLBACK TO SAVEPOINT
 
 You can rollback your transaction to the specified savepoint, but before it you must create it.

README.md

@@ -10,6 +10,12 @@ class QueryResult:
     def result(self: Self) -> list[dict[Any, Any]]:
         """Return result from database as a list of dicts."""
 
+class SingleQueryResult:
+    """Single result."""
+
+    def result(self: Self) -> dict[Any, Any]:
+        """Return result from database as a dict."""
+
 class IsolationLevel(Enum):
     """Class for Isolation Level for transactions."""
 
@@ -269,6 +275,108 @@ class Transaction:
             # This way transaction begins and commits by itself.
         ```
         """
+    async def execute_many(
+        self: Self,
+        querystring: str,
+        parameters: list[list[Any]] | None = None,
+    ) -> None: ...
+    """Execute query multiple times with different parameters.
+
+        Querystring can contain `$<number>` parameters
+        for converting them in the driver side.
+
+        ### Parameters:
+        - `querystring`: querystring to execute.
+        - `parameters`: list of list of parameters to pass in the query.
+
+        ### Example:
+        ```python
+        import asyncio
+
+        from psqlpy import PSQLPool, QueryResult
+
+
+        async def main() -> None:
+            db_pool = PSQLPool()
+            await db_pool.startup()
+
+            transaction = await db_pool.transaction()
+            await transaction.begin()
+            query_result: QueryResult = await transaction.execute_many(
+                "INSERT INTO users (name, age) VALUES ($1, $2)",
+                [["boba", 10], ["boba", 20]],
+            )
+            dict_result: List[Dict[Any, Any]] = query_result.result()
+            # You must call commit manually
+            await transaction.commit()
+
+        # Or you can transaction as a async context manager
+
+        async def main() -> None:
+            db_pool = PSQLPool()
+            await psqlpy.startup()
+
+            transaction = await db_pool.transaction()
+            async with transaction:
+                query_result: QueryResult = await transaction.execute(
+                    "SELECT username FROM users WHERE id = $1",
+                    [100],
+                )
+                dict_result: List[Dict[Any, Any]] = query_result.result()
+            # This way transaction begins and commits by itself.
+        ```
+        """
+    async def fetch_row(
+        self: Self,
+        querystring: str,
+        parameters: list[Any] | None = None,
+    ) -> SingleQueryResult:
+        """Execute the query and return first row.
+
+        Querystring can contain `$<number>` parameters
+        for converting them in the driver side.
+
+        ### Parameters:
+        - `querystring`: querystring to execute.
+        - `parameters`: list of parameters to pass in the query.
+
+        ### Example:
+        ```python
+        import asyncio
+
+        from psqlpy import PSQLPool, QueryResult
+
+
+        async def main() -> None:
+            db_pool = PSQLPool()
+            await db_pool.startup()
+
+            transaction = await db_pool.transaction()
+            await transaction.begin()
+            query_result: SingleQueryResult = await transaction.execute(
+                "SELECT username FROM users WHERE id = $1",
+                [100],
+            )
+            dict_result: Dict[Any, Any] = query_result.result()
+            # You must call commit manually
+            await transaction.commit()
+
+        # Or you can transaction as a async context manager
+
+        async def main() -> None:
+            db_pool = PSQLPool()
+            await psqlpy.startup()
+
+            transaction = await db_pool.transaction()
+            async with transaction:
+                query_result: SingleQueryResult = await transaction.execute(
+                    "SELECT username FROM users WHERE id = $1",
+                    [100],
+                )
+                dict_result: Dict[Any, Any] = query_result.result()
+            # This way transaction begins and commits by itself.
+        ```
+        """
     async def savepoint(self: Self, savepoint_name: str) -> None:
         """Create new savepoint.
 

python/psqlpy/_internal/__init__.pyi

@@ -0,0 +1,13 @@
+import typing
+
+from psqlpy import Transaction
+
+
+async def count_rows_in_test_table(
+    table_name: str,
+    transaction: Transaction,
+) -> int:
+    query_result: typing.Final = await transaction.execute(
+        f"SELECT COUNT(*) FROM {table_name}",
+    )
+    return query_result.result()[0]["count"]

python/tests/helpers.py

@@ -2,8 +2,9 @@
 
 from psqlpy import PSQLPool, QueryResult, Transaction
 
+pytestmark = pytest.mark.anyio
+
 
-@pytest.mark.anyio()
 async def test_connection_execute(
     psql_pool: PSQLPool,
     table_name: str,
@@ -19,7 +20,6 @@ async def test_connection_execute(
     assert len(conn_result.result()) == number_database_records
 
 
-@pytest.mark.anyio()
 async def test_connection_transaction(
     psql_pool: PSQLPool,
 ) -> None:

python/tests/test_connection.py

@@ -2,8 +2,9 @@
 
 from psqlpy import Connection, ConnRecyclingMethod, PSQLPool, QueryResult
 
+pytestmark = pytest.mark.anyio
+
 
-@pytest.mark.anyio()
 async def test_pool_dsn_startup() -> None:
     """Test that connection pool can startup with dsn."""
     pg_pool = PSQLPool(
@@ -14,7 +15,6 @@ async def test_pool_dsn_startup() -> None:
     await pg_pool.execute("SELECT 1")
 
 
-@pytest.mark.anyio()
 async def test_pool_execute(
     psql_pool: PSQLPool,
     table_name: str,
@@ -32,7 +32,6 @@ async def test_pool_execute(
     assert len(inner_result) == number_database_records
 
 
-@pytest.mark.anyio()
 async def test_pool_connection(
     psql_pool: PSQLPool,
 ) -> None:
@@ -41,7 +40,6 @@ async def test_pool_connection(
     assert isinstance(connection, Connection)
 
 
-@pytest.mark.anyio()
 @pytest.mark.parametrize(
     "conn_recycling_method",
     [

python/tests/test_connection_pool.py

@@ -2,8 +2,9 @@
 
 from psqlpy import Cursor
 
+pytestmark = pytest.mark.anyio
+
 
-@pytest.mark.anyio()
 async def test_cursor_fetch(
     number_database_records: int,
     test_cursor: Cursor,
@@ -13,7 +14,6 @@ async def test_cursor_fetch(
     assert len(result.result()) == number_database_records // 2
 
 
-@pytest.mark.anyio()
 async def test_cursor_fetch_next(
     test_cursor: Cursor,
 ) -> None:
@@ -22,7 +22,6 @@ async def test_cursor_fetch_next(
     assert len(result.result()) == 1
 
 
-@pytest.mark.anyio()
 async def test_cursor_fetch_prior(
     test_cursor: Cursor,
 ) -> None:
@@ -35,7 +34,6 @@ async def test_cursor_fetch_prior(
     assert len(result.result()) == 1
 
 
-@pytest.mark.anyio()
 async def test_cursor_fetch_first(
     test_cursor: Cursor,
 ) -> None:
@@ -49,7 +47,6 @@ async def test_cursor_fetch_first(
     assert fetch_first.result() == first.result()
 
 
-@pytest.mark.anyio()
 async def test_cursor_fetch_last(
     test_cursor: Cursor,
     number_database_records: int,
@@ -64,7 +61,6 @@ async def test_cursor_fetch_last(
     assert all_res.result()[-1] == last_res.result()[0]
 
 
-@pytest.mark.anyio()
 async def test_cursor_fetch_absolute(
     test_cursor: Cursor,
     number_database_records: int,
@@ -85,7 +81,6 @@ async def test_cursor_fetch_absolute(
     assert all_res.result()[-1] == last_record.result()[0]
 
 
-@pytest.mark.anyio()
 async def test_cursor_fetch_relative(
     test_cursor: Cursor,
     number_database_records: int,
@@ -107,7 +102,6 @@ async def test_cursor_fetch_relative(
     assert not (records.result())
 
 
-@pytest.mark.anyio()
 async def test_cursor_fetch_forward_all(
     test_cursor: Cursor,
     number_database_records: int,
@@ -124,7 +118,6 @@ async def test_cursor_fetch_forward_all(
     )
 
 
-@pytest.mark.anyio()
 async def test_cursor_fetch_backward(
     test_cursor: Cursor,
 ) -> None:
@@ -142,7 +135,6 @@ async def test_cursor_fetch_backward(
     assert len(must_not_be_empty.result()) == expected_number_of_results
 
 
-@pytest.mark.anyio()
 async def test_cursor_fetch_backward_all(
     test_cursor: Cursor,
 ) -> None: