Added test for synchronous_commit option

chandr-andr · chandr-andr · commit ff53fa797a5e · 2024-09-25T23:47:18.000+02:00
Signed-off-by: chandr-andr (Kiselev Aleksandr) &lt;chandr@chandr.net&gt;
diff --git a/python/psqlpy/__init__.py b/python/psqlpy/__init__.py
@@ -11,6 +11,7 @@
     ReadVariant,
     SingleQueryResult,
     SslMode,
+    SynchronousCommit,
     TargetSessionAttrs,
     Transaction,
     connect,
@@ -32,4 +33,5 @@
     "SslMode",
     "KeepaliveConfig",
     "ConnectionPoolBuilder",
+    "SynchronousCommit",
 ]
diff --git a/python/psqlpy/_internal/__init__.pyi b/python/psqlpy/_internal/__init__.pyi
@@ -152,6 +152,38 @@ class SingleQueryResult:
         Type that return passed function.
         """
 
+class SynchronousCommit(Enum):
+    """
+    Class for synchronous_commit option for transactions.
+
+    ### Variants:
+    - `On`: The meaning may change based on whether you have
+        a synchronous standby or not.
+        If there is a synchronous standby,
+        setting the value to on will result in waiting till “remote flush”.
+    - `Off`: As the name indicates, the commit acknowledgment can come before
+        flushing the records to disk.
+        This is generally called as an asynchronous commit.
+        If the PostgreSQL instance crashes,
+        the last few asynchronous commits might be lost.
+    - `Local`: WAL records are written and flushed to local disks.
+        In this case, the commit will be acknowledged after the
+        local WAL Write and WAL flush completes.
+    - `RemoteWrite`: WAL records are successfully handed over to
+        remote instances which acknowledged back
+        about the write (not flush).
+    - `RemoteApply`: This will result in commits waiting until replies from the
+        current synchronous standby(s) indicate they have received
+        the commit record of the transaction and applied it so
+        that it has become visible to queries on the standby(s).
+    """
+
+    On = 1
+    Off = 2
+    Local = 3
+    RemoteWrite = 4
+    RemoteApply = 5
+
 class IsolationLevel(Enum):
     """Class for Isolation Level for transactions."""
 
@@ -1050,13 +1082,15 @@ class Connection:
         isolation_level: IsolationLevel | None = None,
         read_variant: ReadVariant | None = None,
         deferrable: bool | None = None,
+        synchronous_commit: SynchronousCommit | None = None,
     ) -> Transaction:
         """Create new transaction.
 
         ### Parameters:
         - `isolation_level`: configure isolation level of the transaction.
         - `read_variant`: configure read variant of the transaction.
         - `deferrable`: configure deferrable of the transaction.
+        - `synchronous_commit`: configure synchronous_commit option for transaction.
         """
     def cursor(
         self: Self,
diff --git a/python/tests/test_transaction.py b/python/tests/test_transaction.py
@@ -9,7 +9,13 @@
 from pyarrow import parquet
 from tests.helpers import count_rows_in_test_table
 
-from psqlpy import ConnectionPool, Cursor, IsolationLevel, ReadVariant
+from psqlpy import (
+    ConnectionPool,
+    Cursor,
+    IsolationLevel,
+    ReadVariant,
+    SynchronousCommit,
+)
 from psqlpy.exceptions import (
     RustPSQLDriverPyBaseError,
     TransactionBeginError,
@@ -401,3 +407,27 @@ async def test_execute_batch_method(psql_pool: ConnectionPool) -> None:
         await transaction.execute_batch(querystring=query)
         await transaction.execute(querystring="SELECT * FROM execute_batch")
         await transaction.execute(querystring="SELECT * FROM execute_batch2")
+
+
+@pytest.mark.parametrize(
+    "synchronous_commit",
+    (
+        SynchronousCommit.On,
+        SynchronousCommit.Off,
+        SynchronousCommit.Local,
+        SynchronousCommit.RemoteWrite,
+        SynchronousCommit.RemoteApply,
+    ),
+)
+async def test_synchronous_commit(
+    synchronous_commit: SynchronousCommit,
+    psql_pool: ConnectionPool,
+    table_name: str,
+    number_database_records: int,
+) -> None:
+    async with psql_pool.acquire() as conn, conn.transaction(synchronous_commit=synchronous_commit) as trans:
+        res = await trans.execute(
+            f"SELECT * FROM {table_name}",
+        )
+
+        assert len(res.result()) == number_database_records
diff --git a/src/lib.rs b/src/lib.rs
@@ -26,6 +26,7 @@ fn psqlpy(py: Python<'_>, pymod: &Bound<'_, PyModule>) -> PyResult<()> {
     pymod.add_class::<driver::transaction::Transaction>()?;
     pymod.add_class::<driver::cursor::Cursor>()?;
     pymod.add_class::<driver::transaction_options::IsolationLevel>()?;
+    pymod.add_class::<driver::transaction_options::SynchronousCommit>()?;
     pymod.add_class::<driver::transaction_options::ReadVariant>()?;
     pymod.add_class::<driver::common_options::ConnRecyclingMethod>()?;
     pymod.add_class::<driver::common_options::LoadBalanceHosts>()?;
