Added more documentation and added one test

Author: chandr-andr

docs/components/connection.md

@@ -24,11 +24,10 @@ async def main() -> None:
 ```python
 from psqlpy import connect
 
-db_connection: Final = connect(
-    dsn="postgres://postgres:postgres@localhost:5432/postgres",
-)
-
 async def main() -> None:
+    db_connection: Final = await connect(
+        dsn="postgres://postgres:postgres@localhost:5432/postgres",
+    )
     await db_connection.execute(...)
 ```
 

docs/components/cursor.md

@@ -61,12 +61,34 @@ async def main() -> None:
     async with connection.cursor(
         querystring="SELECT * FROM users WHERE id > $1",
         parameters=[100],
-        fetch_number=10,
+        array_size=10,
     ) as cursor:
         result: QueryResult = await cursor.fetchone()
 ```
+
+@tab Async Iterator
+```python
+from psqlpy import ConnectionPool, QueryResult
+
+async def main() -> None:
+    db_pool = ConnectionPool()
+    connection = await db_pool.connection()
+
+    cursor = connection.cursor(
+        querystring="SELECT * FROM users WHERE id > $1",
+        parameters=[100],
+        fetch_number=10,
+    )
+    await cursor.start()
+
+    async for result in cursor:
+        print(result)
+```
 :::
 
+## Cursor attributes
+- `array_size`: get and set attribute. Used in async iterator and `fetch_many` method.
+
 ## Cursor methods
 ### Start
 Declare (create) cursor.
@@ -117,7 +139,7 @@ async def main() -> None:
 
 ### Fetchmany
 
-Fetch N results from the cursor.
+Fetch N results from the cursor. Default is `array_size`.
 
 #### Parameters:
 - `size`: number of records to fetch.

python/tests/test_cursor.py

@@ -65,6 +65,22 @@ async def test_cursor_as_async_context_manager(
     assert len(results.result()) == number_database_records
 
 
+async def test_cursor_as_async_iterator(
+    psql_pool: ConnectionPool,
+    table_name: str,
+    number_database_records: int,
+) -> None:
+    connection = await psql_pool.connection()
+    all_results = []
+    async with connection.cursor(
+        querystring=f"SELECT * FROM {table_name}",
+    ) as cursor:
+        async for results in cursor:
+            all_results.extend(results.result())
+
+    assert len(all_results) == number_database_records
+
+
 async def test_cursor_send_underlying_connection_to_pool(
     psql_pool: ConnectionPool,
     table_name: str,

src/driver/common.rs

@@ -132,18 +132,18 @@ macro_rules! impl_cursor_method {
     ($name:ident) => {
         #[pymethods]
         impl $name {
-            #[pyo3(signature = (querystring=None, parameters=None, fetch_number=None))]
+            #[pyo3(signature = (querystring=None, parameters=None, array_size=None))]
             pub fn cursor(
                 &self,
                 querystring: Option<String>,
                 parameters: Option<Py<PyAny>>,
-                fetch_number: Option<i32>,
+                array_size: Option<i32>,
             ) -> PSQLPyResult<Cursor> {
                 Ok(Cursor::new(
                     self.conn.clone(),
                     querystring,
                     parameters,
-                    fetch_number,
+                    array_size,
                     self.pg_config.clone(),
                     None,
                 ))

src/driver/connection.rs

@@ -1,5 +1,5 @@
 use deadpool_postgres::Pool;
-use pyo3::{ffi::PyObject, pyclass, pyfunction, pymethods, Py, PyAny, PyErr};
+use pyo3::{pyclass, pyfunction, pymethods, Py, PyAny, PyErr};
 use std::sync::Arc;
 use tokio::sync::RwLock;
 use tokio_postgres::Config;

src/driver/cursor.rs

@@ -1,8 +1,7 @@
 use std::sync::Arc;
 
 use pyo3::{
-    exceptions::PyStopAsyncIteration, pyclass, pymethods, types::PyNone, Py, PyAny, PyErr,
-    PyObject, Python,
+    exceptions::PyStopAsyncIteration, pyclass, pymethods, Py, PyAny, PyErr, PyObject, Python,
 };
 use tokio::sync::RwLock;
 use tokio_postgres::{Config, Portal as tp_Portal};