Added read property for transaction creation

Author: chandr-andr

README.md

@@ -26,7 +26,6 @@ Usage is as easy as possible.
 Create new instance of PSQLPool, startup it and start querying.
 ```python
 from typing import Any
-import asyncio
 
 from psqlpy import PSQLPool
 
@@ -70,7 +69,6 @@ Any placeholder must be marked with `$< num>`.
 You can work with connection instead of DatabasePool.
 ```python
 from typing import Any
-import asyncio
 
 from psqlpy import PSQLPool
 
@@ -102,11 +100,16 @@ async def main() -> None:
 Of course it's possible to use transactions with this driver.  
 It's as easy as possible and sometimes it copies common functionality from PsycoPG and AsyncPG.
 
+### Transaction parameters
+In process of transaction creation it is possible to specify some arguments to configure transaction.
+
+- `isolation_level`: level of the isolation. By default - `None`.
+- `read_variant`: read option. By default - `None`.
+
 ### You can use transactions as async context managers
 By default async context manager only begins and commits transaction automatically.
 ```python
 from typing import Any
-import asyncio
 
 from psqlpy import PSQLPool, IsolationLevel
 
@@ -134,7 +137,6 @@ async def main() -> None:
 ### Or you can control transaction fully on your own.
 ```python
 from typing import Any
-import asyncio
 
 from psqlpy import PSQLPool, IsolationLevel
 
@@ -169,7 +171,6 @@ After it's execution transaction state changes to `done`.
 If you want to use `ROLLBACK TO SAVEPOINT`, see below.
 ```python
 from typing import Any
-import asyncio
 
 from psqlpy import PSQLPool, IsolationLevel
 
@@ -197,7 +198,6 @@ You can rollback your transaction to the specified savepoint, but before it you
 
 ```python
 from typing import Any
-import asyncio
 
 from psqlpy import PSQLPool, IsolationLevel
 
@@ -231,7 +231,6 @@ It's possible to release savepoint
 
 ```python
 from typing import Any
-import asyncio
 
 from psqlpy import PSQLPool, IsolationLevel
 
@@ -262,7 +261,6 @@ Cursors can be created only in transaction. In addition, cursor supports async i
 
 ```python
 from typing import Any
-import asyncio
 
 from psqlpy import PSQLPool, IsolationLevel
 
@@ -304,7 +302,7 @@ Sometimes it's impossible to identify which type user tries to pass as a argumen
 
 ```python
 from typing import Any
-import asyncio
+
 import uuid
 
 from psqlpy import PSQLPool

python/psqlpy/__init__.py

@@ -1,11 +1,9 @@
-from ._internal import PSQLPool, QueryResult, Transaction, IsolationLevel
+from ._internal import PSQLPool, QueryResult, Transaction, IsolationLevel, ReadVariant
 
 __all__ = [
     "PSQLPool",
     "QueryResult",
     "Transaction",
-    "SmallInt",
-    "Integer",
-    "BigInt",
     "IsolationLevel",
+    "ReadVariant",
 ]

python/psqlpy/_internal/__init__.pyi

@@ -21,6 +21,13 @@ class IsolationLevel(Enum):
     Serializable = 4
 
 
+class ReadVariant(Enum):
+    """Class for Read Variant for transaction."""
+
+    ReadOnly = 1
+    ReadWrite = 2
+
+
 class Cursor:
     """Represent opened cursor in a transaction.
     
@@ -325,12 +332,14 @@ class Connection:
 
     async def transaction(
         self,
-        isolation_level: IsolationLevel | None = IsolationLevel.ReadCommitted,
+        isolation_level: IsolationLevel | None = None,
+        read_variant: ReadVariant | None = None,
     ) -> Transaction:
         """Create new transaction.
 
         ### Parameters:
         - `isolation_level`: configure isolation level of the transaction.
+        - `read_variant`: configure read variant of the transaction.
         """
 
 

src/driver/connection.rs

@@ -12,7 +12,7 @@ use crate::{
 
 use super::{
     transaction::{RustTransaction, Transaction},
-    transaction_options::IsolationLevel,
+    transaction_options::{IsolationLevel, ReadVariant},
 };
 
 pub struct RustConnection {
@@ -55,15 +55,20 @@ impl RustConnection {
         Ok(PSQLDriverPyQueryResult::new(result))
     }
 
-    pub fn inner_transaction<'a>(&'a self, isolation_level: Option<IsolationLevel>) -> Transaction {
-        let inner_transaction = RustTransaction {
-            db_client: self.db_client.clone(),
-            is_started: Arc::new(tokio::sync::RwLock::new(false)),
-            is_done: Arc::new(tokio::sync::RwLock::new(false)),
-            rollback_savepoint: Arc::new(tokio::sync::RwLock::new(HashSet::new())),
-            isolation_level: isolation_level,
-            cursor_num: Default::default(),
-        };
+    pub fn inner_transaction<'a>(
+        &'a self,
+        isolation_level: Option<IsolationLevel>,
+        read_variant: Option<ReadVariant>,
+    ) -> Transaction {
+        let inner_transaction = RustTransaction::new(
+            self.db_client.clone(),
+            Arc::new(tokio::sync::RwLock::new(false)),
+            Arc::new(tokio::sync::RwLock::new(false)),
+            Arc::new(tokio::sync::RwLock::new(HashSet::new())),
+            isolation_level,
+            read_variant,
+            Default::default(),
+        );
 
         Transaction {
             transaction: Arc::new(tokio::sync::RwLock::new(inner_transaction)),
@@ -108,12 +113,13 @@ impl Connection {
         &'a self,
         py: Python<'a>,
         isolation_level: Option<IsolationLevel>,
+        read_variant: Option<ReadVariant>,
     ) -> RustPSQLDriverPyResult<&PyAny> {
         let connection_arc = self.0.clone();
 
         rustengine_future(py, async move {
             let connection_guard = connection_arc.read().await;
-            Ok(connection_guard.inner_transaction(isolation_level))
+            Ok(connection_guard.inner_transaction(isolation_level, read_variant))
         })
     }
 }

src/driver/connection_pool.rs

@@ -1,20 +1,16 @@
 use deadpool_postgres::{Manager, ManagerConfig, Pool, RecyclingMethod};
 use pyo3::{pyclass, pymethods, PyAny, Python};
-use std::{collections::HashSet, sync::Arc, vec};
+use std::{sync::Arc, vec};
 use tokio_postgres::{types::ToSql, NoTls};
 
 use crate::{
     common::rustengine_future,
-    driver::transaction::{RustTransaction, Transaction},
     exceptions::rust_errors::{RustPSQLDriverError, RustPSQLDriverPyResult},
     query_result::PSQLDriverPyQueryResult,
     value_converter::{convert_parameters, PythonDTO},
 };
 
-use super::{
-    connection::{Connection, RustConnection},
-    transaction_options::IsolationLevel,
-};
+use super::connection::{Connection, RustConnection};
 
 /// PSQLPool for internal use only.
 ///
@@ -111,39 +107,6 @@ impl RustPSQLPool {
         Ok(PSQLDriverPyQueryResult::new(result))
     }
 
-    /// Create new inner transaction and return it.
-    ///
-    /// # Errors:
-    /// May return Err Result if cannot retrieve connection from the pool.
-    pub async fn inner_transaction<'a>(
-        &'a self,
-        isolation_level: Option<IsolationLevel>,
-    ) -> RustPSQLDriverPyResult<Transaction> {
-        let db_pool_arc = self.db_pool.clone();
-        let db_pool_guard = db_pool_arc.read().await;
-
-        let db_pool_manager = db_pool_guard
-            .as_ref()
-            .ok_or(RustPSQLDriverError::DatabasePoolError(
-                "Database pool is not initialized".into(),
-            ))?
-            .get()
-            .await?;
-
-        let inner_transaction = RustTransaction {
-            db_client: Arc::new(tokio::sync::RwLock::new(db_pool_manager)),
-            is_started: Arc::new(tokio::sync::RwLock::new(false)),
-            is_done: Arc::new(tokio::sync::RwLock::new(false)),
-            rollback_savepoint: Arc::new(tokio::sync::RwLock::new(HashSet::new())),
-            isolation_level: isolation_level,
-            cursor_num: Default::default(),
-        };
-
-        Ok(Transaction {
-            transaction: Arc::new(tokio::sync::RwLock::new(inner_transaction)),
-        })
-    }
-
     /// Create new Database pool.
     ///
     /// # Errors:

src/driver/transaction.rs

@@ -10,22 +10,46 @@ use crate::{
     value_converter::{convert_parameters, PythonDTO},
 };
 
-use super::{cursor::Cursor, transaction_options::IsolationLevel};
+use super::{
+    cursor::Cursor,
+    transaction_options::{IsolationLevel, ReadVariant},
+};
 
 /// Transaction for internal use only.
 ///
 /// It is not exposed to python.
 pub struct RustTransaction {
-    pub db_client: Arc<tokio::sync::RwLock<Object>>,
-    pub is_started: Arc<tokio::sync::RwLock<bool>>,
-    pub is_done: Arc<tokio::sync::RwLock<bool>>,
-    pub rollback_savepoint: Arc<tokio::sync::RwLock<HashSet<String>>>,
-
-    pub isolation_level: Option<IsolationLevel>,
-    pub cursor_num: usize,
+    db_client: Arc<tokio::sync::RwLock<Object>>,
+    is_started: Arc<tokio::sync::RwLock<bool>>,
+    is_done: Arc<tokio::sync::RwLock<bool>>,
+    rollback_savepoint: Arc<tokio::sync::RwLock<HashSet<String>>>,
+
+    isolation_level: Option<IsolationLevel>,
+    read_variant: Option<ReadVariant>,
+    cursor_num: usize,
 }
 
 impl RustTransaction {
+    pub fn new(
+        db_client: Arc<tokio::sync::RwLock<Object>>,
+        is_started: Arc<tokio::sync::RwLock<bool>>,
+        is_done: Arc<tokio::sync::RwLock<bool>>,
+        rollback_savepoint: Arc<tokio::sync::RwLock<HashSet<String>>>,
+        isolation_level: Option<IsolationLevel>,
+        read_variant: Option<ReadVariant>,
+        cursor_num: usize,
+    ) -> Self {
+        Self {
+            db_client,
+            is_started,
+            is_done,
+            rollback_savepoint,
+            isolation_level,
+            read_variant,
+            cursor_num,
+        }
+    }
+
     /// Execute querystring with parameters.
     ///
     /// Method doesn't acquire lock on any structure fields.
@@ -85,11 +109,14 @@ impl RustTransaction {
         let mut querystring = "START TRANSACTION".to_string();
 
         if let Some(level) = self.isolation_level {
-            querystring.push_str(" ISOLATION LEVEL ");
             let level = &level.to_str_level();
-            querystring.push_str(level);
+            querystring.push_str(format!(" ISOLATION LEVEL {level}").as_str());
         };
 
+        if let Some(read_var) = self.read_variant {
+            querystring.push_str(format!(" {}", &read_var.to_str_option()).as_str())
+        }
+
         let db_client_arc = self.db_client.clone();
         let db_client_guard = db_client_arc.read().await;
 

src/driver/transaction_options.rs

@@ -3,10 +3,10 @@ use pyo3::pyclass;
 #[pyclass]
 #[derive(Clone, Copy)]
 pub enum IsolationLevel {
-    ReadUncommitted = 1,
-    ReadCommitted = 2,
-    RepeatableRead = 3,
-    Serializable = 4,
+    ReadUncommitted,
+    ReadCommitted,
+    RepeatableRead,
+    Serializable,
 }
 
 impl IsolationLevel {
@@ -20,3 +20,20 @@ impl IsolationLevel {
         }
     }
 }
+
+#[pyclass]
+#[derive(Clone, Copy)]
+pub enum ReadVariant {
+    ReadOnly,
+    ReadWrite,
+}
+
+impl ReadVariant {
+    /// Return Read variant as String literal.
+    pub fn to_str_option(&self) -> String {
+        match self {
+            ReadVariant::ReadOnly => "READ ONLY".into(),
+            ReadVariant::ReadWrite => "READ WRITE".into(),
+        }
+    }
+}

src/lib.rs

@@ -17,6 +17,7 @@ fn psqlpy(py: Python<'_>, pymod: &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::ReadVariant>()?;
     pymod.add_class::<query_result::PSQLDriverPyQueryResult>()?;
     add_module(py, pymod, "extra_types", extra_types_module)?;
     add_module(py, pymod, "exceptions", python_exceptions_module)?;