Added performance improvement

Author: chandr-andr

docs/components/results.md

@@ -33,7 +33,7 @@ async def main() -> None:
     list_dict_result: List[Dict[str, Any]] = query_result.result()
 
     # Result as tuple
-    list_tuple_result: List[Tuple[str, typing.Any], ...] = query_result.result(
+    list_tuple_result: List[Tuple[t.Any, ...]] = query_result.result(
         as_tuple=True,
     )
 ```
@@ -100,7 +100,7 @@ async def main() -> None:
     dict_result: Dict[str, Any] = query_result.result()
 
     # Result as tuple
-    tuple_result: Tuple[str, typing.Any] = query_result.result(
+    tuple_result: Tuple[typing.Any, ...] = query_result.result(
         as_tuple=True,
     )
 ```

python/tests/conftest.py

@@ -134,69 +134,76 @@ async def create_default_data_for_tests(
     table_name: str,
     number_database_records: int,
 ) -> AsyncGenerator[None, None]:
-    connection = await psql_pool.connection()
-    await connection.execute(
-        f"CREATE TABLE {table_name} (id SERIAL, name VARCHAR(255))",
-    )
-
-    for table_id in range(1, number_database_records + 1):
-        new_name = random_string()
+    async with psql_pool.acquire() as connection:
         await connection.execute(
-            querystring=f"INSERT INTO {table_name} VALUES ($1, $2)",
-            parameters=[table_id, new_name],
+            f"CREATE TABLE {table_name} (id SERIAL, name VARCHAR(255))",
         )
+
+        for table_id in range(1, number_database_records + 1):
+            new_name = random_string()
+            await connection.execute(
+                querystring=f"INSERT INTO {table_name} VALUES ($1, $2)",
+                parameters=[table_id, new_name],
+            )
+
     yield
-    await connection.execute(
-        f"DROP TABLE {table_name}",
-    )
+
+    async with psql_pool.acquire() as connection:
+        await connection.execute(
+            f"DROP TABLE {table_name}",
+        )
 
 
 @pytest.fixture
 async def create_table_for_listener_tests(
     psql_pool: ConnectionPool,
     listener_table_name: str,
 ) -> AsyncGenerator[None, None]:
-    connection = await psql_pool.connection()
-    await connection.execute(
-        f"CREATE TABLE {listener_table_name}"
-        f"(id SERIAL, payload VARCHAR(255),"
-        f"channel VARCHAR(255), process_id INT)",
-    )
+    async with psql_pool.acquire() as connection:
+        await connection.execute(
+            f"CREATE TABLE {listener_table_name}"
+            f"(id SERIAL, payload VARCHAR(255),"
+            f"channel VARCHAR(255), process_id INT)",
+        )
 
     yield
-    await connection.execute(
-        f"DROP TABLE {listener_table_name}",
-    )
+
+    async with psql_pool.acquire() as connection:
+        await connection.execute(
+            f"DROP TABLE {listener_table_name}",
+        )
 
 
 @pytest.fixture
 async def create_table_for_map_parameters_test(
     psql_pool: ConnectionPool,
     map_parameters_table_name: str,
 ) -> AsyncGenerator[None, None]:
-    connection = await psql_pool.connection()
-    await connection.execute(
-        f"CREATE TABLE {map_parameters_table_name}"
-        "(id SERIAL, name VARCHAR(255),surname VARCHAR(255), age SMALLINT)",
-    )
+    async with psql_pool.acquire() as connection:
+        await connection.execute(
+            f"CREATE TABLE {map_parameters_table_name}"
+            "(id SERIAL, name VARCHAR(255),surname VARCHAR(255), age SMALLINT)",
+        )
 
     yield
-    await connection.execute(
-        f"DROP TABLE {map_parameters_table_name}",
-    )
+
+    async with psql_pool.acquire() as connection:
+        await connection.execute(
+            f"DROP TABLE {map_parameters_table_name}",
+        )
 
 
 @pytest.fixture
 async def test_cursor(
     psql_pool: ConnectionPool,
     table_name: str,
 ) -> AsyncGenerator[Cursor, None]:
-    connection = await psql_pool.connection()
-    transaction = connection.transaction()
-    await transaction.begin()
-    cursor = transaction.cursor(
-        querystring=f"SELECT * FROM {table_name}",
-    )
-    await cursor.start()
-    yield cursor
-    await transaction.commit()
+    async with psql_pool.acquire() as connection:
+        transaction = connection.transaction()
+        await transaction.begin()
+        cursor = transaction.cursor(
+            querystring=f"SELECT * FROM {table_name}",
+        )
+        await cursor.start()
+        yield cursor
+        await transaction.commit()

src/connection/impls.rs

@@ -367,6 +367,31 @@ impl PSQLPyConnection {
         Ok(PSQLDriverPyQueryResult::new(result))
     }
 
+    /// Execute raw querystring without parameters.
+    ///
+    /// # Errors
+    /// May return error if there is some problem with DB communication.
+    pub async fn execute_no_params(
+        &self,
+        querystring: String,
+        prepared: Option<bool>,
+    ) -> PSQLPyResult<PSQLDriverPyQueryResult> {
+        let prepared = prepared.unwrap_or(true);
+        let result = if prepared {
+            self.query(&querystring, &[]).await
+        } else {
+            self.query_typed(&querystring, &[]).await
+        };
+
+        let return_result = result.map_err(|err| {
+            RustPSQLDriverError::ConnectionExecuteError(format!(
+                "Cannot execute query, error - {err}"
+            ))
+        })?;
+
+        Ok(PSQLDriverPyQueryResult::new(return_result))
+    }
+
     /// Execute raw query with parameters.
     ///
     /// # Errors

src/driver/connection.rs

@@ -237,8 +237,13 @@ impl Connection {
 
         if let Some(db_client) = db_client {
             let read_conn_g = db_client.read().await;
-            let res = read_conn_g.execute(querystring, parameters, prepared).await;
-            return res;
+            return {
+                if parameters.is_some() {
+                    read_conn_g.execute(querystring, parameters, prepared).await
+                } else {
+                    read_conn_g.execute_no_params(querystring, prepared).await
+                }
+            };
         }
 
         Err(RustPSQLDriverError::ConnectionClosedError)
@@ -318,7 +323,13 @@ impl Connection {
 
         if let Some(db_client) = db_client {
             let read_conn_g = db_client.read().await;
-            return read_conn_g.execute(querystring, parameters, prepared).await;
+            return {
+                if parameters.is_some() {
+                    read_conn_g.execute(querystring, parameters, prepared).await
+                } else {
+                    read_conn_g.execute_no_params(querystring, prepared).await
+                }
+            };
         }
 
         Err(RustPSQLDriverError::ConnectionClosedError)