Continue implementing execute_many in transaction

Author: insani7y

python/psqlpy/_internal/__init__.pyi

@@ -255,6 +255,57 @@ class Transaction:
 
         # 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 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()

src/driver/transaction.rs

@@ -146,18 +146,29 @@ impl RustTransaction {
                 "Transaction is already committed or rolled back".into(),
             ));
         }
+        if parameters.len() == 0 {
+            return Err(RustPSQLDriverError::DataBaseTransactionError(
+                "No parameters passed to execute_many".into(),
+            ));
+        }
+        let mut vec_parameters: Vec<Box<dyn ToSql + Sync>> =
+            Vec::with_capacity(parameters[0].len());
         for single_parameters in parameters {
-            let mut vec_parameters: Vec<&(dyn ToSql + Sync)> =
-                Vec::with_capacity(single_parameters.len());
-            for param in &single_parameters {
-                vec_parameters.push(param);
+            for param in single_parameters {
+                vec_parameters.push(Box::new(param));
             }
 
             let statement = db_client_guard.prepare_cached(&querystring).await?;
-
             db_client_guard
-                .query(&statement, &vec_parameters.into_boxed_slice())
+                .query(
+                    &statement,
+                    &*vec_parameters
+                        .iter()
+                        .map(|p| &**p as &(dyn ToSql + Sync))
+                        .collect::<Vec<_>>(),
+                )
                 .await?;
+            vec_parameters.clear()
         }
 
         Ok(())