Merge pull request #23 from qaspen-python/feature/add_performance_changes

Added some performance changes

Author: insani7y

Cargo.lock

@@ -33,7 +33,8 @@ Or you can build it by yourself. To do it, install stable rust and [maturin](htt
 ## Usage
 
 Usage is as easy as possible.
-Create new instance of PSQLPool, startup it and start querying.
+Create new instance of PSQLPool and start querying.
+You don't need to startup connection pool, the connection pool will create connections as needed.
 
 ```python
 from typing import Any
@@ -51,8 +52,34 @@ db_pool = PSQLPool(
 )
 
 async def main() -> None:
-    await db_pool.startup()
+    res: QueryResult = await db_pool.execute(
+        "SELECT * FROM users",
+    )
 
+    print(res.result())
+    # You don't need to close Database Pool by yourself,
+    # rust does it instead.
+
+```
+
+Or you can create connection pool with this function:
+
+```python
+from typing import Any
+
+from psqlpy import PSQLPool, QueryResult, create_connection_pool
+
+
+db_pool: PSQLPool = create_connection_pool(
+    username="postgres",
+    password="pg_password",
+    host="localhost",
+    port=5432,
+    db_name="postgres",
+    max_db_pool_size=2,
+)
+
+async def main() -> None:
     res: QueryResult = await db_pool.execute(
         "SELECT * FROM users",
     )

README.md

@@ -856,3 +856,27 @@ class PSQLPool:
 
         It acquires new connection from the database pool.
         """
+
+def create_connection_pool(
+    dsn: Optional[str] = None,
+    username: Optional[str] = None,
+    password: Optional[str] = None,
+    host: Optional[str] = None,
+    port: Optional[int] = None,
+    db_name: Optional[str] = None,
+    max_db_pool_size: Optional[str] = None,
+    conn_recycling_method: Optional[ConnRecyclingMethod] = None,
+) -> PSQLPool:
+    """Create new connection pool.
+
+    ### Parameters:
+    - `dsn`: full dsn connection string.
+        `postgres://postgres:postgres@localhost:5432/postgres?target_session_attrs=read-write`
+    - `username`: username of the user in postgres
+    - `password`: password of the user in postgres
+    - `host`: host of postgres
+    - `port`: port of postgres
+    - `db_name`: name of the database in postgres
+    - `max_db_pool_size`: maximum size of the connection pool
+    - `conn_recycling_method`: how a connection is recycled.
+    """

python/psqlpy/_internal/__init__.pyi

@@ -81,15 +81,13 @@ async def psql_pool(
     postgres_port: int,
     postgres_dbname: str,
 ) -> PSQLPool:
-    pg_pool = PSQLPool(
+    return PSQLPool(
         username=postgres_user,
         password=postgres_password,
         host=postgres_host,
         port=postgres_port,
         db_name=postgres_dbname,
     )
-    await pg_pool.startup()
-    return pg_pool
 
 
 @pytest.fixture(autouse=True)

python/tests/conftest.py

@@ -11,7 +11,6 @@ async def test_pool_dsn_startup() -> None:
     pg_pool = PSQLPool(
         dsn="postgres://postgres:postgres@localhost:5432/psqlpy_test",
     )
-    await pg_pool.startup()
 
     await pg_pool.execute("SELECT 1")
 
@@ -57,8 +56,6 @@ async def test_pool_conn_recycling_method(
         conn_recycling_method=conn_recycling_method,
     )
 
-    await pg_pool.startup()
-
     await pg_pool.execute("SELECT 1")
 
 
@@ -68,8 +65,6 @@ async def test_close_connection_pool() -> None:
         dsn="postgres://postgres:postgres@localhost:5432/psqlpy_test",
     )
 
-    await pg_pool.startup()
-
     await pg_pool.execute("SELECT 1")
 
     await pg_pool.close()

python/tests/test_connection_pool.py

@@ -35,7 +35,7 @@ pub fn add_module(
 /// # Errors
 ///
 /// May return Err Result if future acts incorrect.
-pub fn rustengine_future<F, T>(py: Python<'_>, future: F) -> RustPSQLDriverPyResult<&PyAny>
+pub fn rustdriver_future<F, T>(py: Python<'_>, future: F) -> RustPSQLDriverPyResult<&PyAny>
 where
     F: Future<Output = RustPSQLDriverPyResult<T>> + Send + 'static,
     T: IntoPy<PyObject>,

src/common.rs

@@ -4,7 +4,7 @@ use std::{collections::HashSet, sync::Arc, vec};
 use tokio_postgres::types::ToSql;
 
 use crate::{
-    common::rustengine_future,
+    common::rustdriver_future,
     exceptions::rust_errors::RustPSQLDriverPyResult,
     query_result::PSQLDriverPyQueryResult,
     value_converter::{convert_parameters, PythonDTO},
@@ -15,85 +15,14 @@ use super::{
     transaction_options::{IsolationLevel, ReadVariant},
 };
 
-#[allow(clippy::module_name_repetitions)]
-pub struct RustConnection {
-    pub db_client: Arc<Object>,
-}
-
-impl RustConnection {
-    #[must_use]
-    pub fn new(db_client: Arc<Object>) -> Self {
-        RustConnection { db_client }
-    }
-    /// Execute statement with or witout parameters.
-    ///
-    /// # Errors
-    ///
-    /// May return Err Result if
-    /// 1) Cannot convert incoming parameters
-    /// 2) Cannot prepare statement
-    /// 3) Cannot execute query
-    pub async fn inner_execute(
-        &self,
-        querystring: String,
-        params: Vec<PythonDTO>,
-        prepared: bool,
-    ) -> RustPSQLDriverPyResult<PSQLDriverPyQueryResult> {
-        let db_client = &self.db_client;
-        let mut vec_parameters: Vec<&(dyn ToSql + Sync)> = Vec::with_capacity(params.len());
-        for param in &params {
-            vec_parameters.push(param);
-        }
-
-        let result = if prepared {
-            db_client
-                .query(
-                    &db_client.prepare_cached(&querystring).await?,
-                    &vec_parameters.into_boxed_slice(),
-                )
-                .await?
-        } else {
-            db_client
-                .query(&querystring, &vec_parameters.into_boxed_slice())
-                .await?
-        };
-
-        Ok(PSQLDriverPyQueryResult::new(result))
-    }
-
-    /// Return new instance of transaction.
-    #[must_use]
-    pub fn inner_transaction(
-        &self,
-        isolation_level: Option<IsolationLevel>,
-        read_variant: Option<ReadVariant>,
-        deferrable: Option<bool>,
-    ) -> Transaction {
-        let inner_transaction = RustTransaction::new(
-            self.db_client.clone(),
-            false,
-            false,
-            Arc::new(tokio::sync::RwLock::new(HashSet::new())),
-            isolation_level,
-            read_variant,
-            deferrable,
-        );
-
-        Transaction::new(
-            Arc::new(tokio::sync::RwLock::new(inner_transaction)),
-            Default::default(),
-        )
-    }
-}
-
 #[pyclass()]
 pub struct Connection {
-    pub inner_connection: Arc<RustConnection>,
+    pub inner_connection: Arc<Object>,
 }
 
 impl Connection {
     #[must_use]
-    pub fn new(inner_connection: Arc<RustConnection>) -> Self {
+    pub fn new(inner_connection: Arc<Object>) -> Self {
         Connection { inner_connection }
     }
 }
@@ -121,10 +50,27 @@ impl Connection {
         if let Some(parameters) = parameters {
             params = convert_parameters(parameters)?;
         }
-        rustengine_future(py, async move {
-            connection_arc
-                .inner_execute(querystring, params, prepared.unwrap_or(true))
-                .await
+        let is_prepared = prepared.unwrap_or(true);
+        rustdriver_future(py, async move {
+            let mut vec_parameters: Vec<&(dyn ToSql + Sync)> = Vec::with_capacity(params.len());
+            for param in &params {
+                vec_parameters.push(param);
+            }
+
+            let result = if is_prepared {
+                connection_arc
+                    .query(
+                        &connection_arc.prepare_cached(&querystring).await?,
+                        &vec_parameters.into_boxed_slice(),
+                    )
+                    .await?
+            } else {
+                connection_arc
+                    .query(&querystring, &vec_parameters.into_boxed_slice())
+                    .await?
+            };
+
+            Ok(PSQLDriverPyQueryResult::new(result))
         })
     }
 
@@ -136,7 +82,19 @@ impl Connection {
         read_variant: Option<ReadVariant>,
         deferrable: Option<bool>,
     ) -> Transaction {
-        self.inner_connection
-            .inner_transaction(isolation_level, read_variant, deferrable)
+        let inner_transaction = RustTransaction::new(
+            self.inner_connection.clone(),
+            false,
+            false,
+            Arc::new(tokio::sync::RwLock::new(HashSet::new())),
+            isolation_level,
+            read_variant,
+            deferrable,
+        );
+
+        Transaction::new(
+            Arc::new(tokio::sync::RwLock::new(inner_transaction)),
+            Default::default(),
+        )
     }
 }