Fixed using connections in type usage docs

Author: Daniil Babin

docs/usage/types/advanced_type_usage.md

@@ -15,20 +15,19 @@ Let's assume we have table `for_test` in the database and `PSQLPy` doesn't suppo
 ```python
 from typing import Final
 
-from psqlpy import Connection, ConnectionPool
+from psqlpy import ConnectionPool
 from psqlpy.extra_types import CustomType
 
 
 async def main() -> None:
     # It uses default connection parameters
     db_pool: Final = ConnectionPool()
-    connection: Connection = await db_pool.connection()
-
-    await connection.execute(
-        "INSERT INTO for_test (nickname) VALUES ($1)",
-        [CustomType(b"SomeDataInBytes")],
-    )
-    connection.close()
+    
+    async with db_pool.acquire() as connection:
+        await connection.execute(
+            "INSERT INTO for_test (nickname) VALUES ($1)",
+            [CustomType(b"SomeDataInBytes")],
+        )
 ```
 
 Here we pass `CustomType` into the parameters. It accepts only bytes.
@@ -49,7 +48,7 @@ Let's assume we have table `for_test` in the database and `PSQLPy` doesn't suppo
 ```python
 from typing import Final, Any
 
-from psqlpy import Connection, ConnectionPool, QueryResult
+from psqlpy import ConnectionPool, QueryResult
 from psqlpy.extra_types import CustomType
 
 
@@ -60,19 +59,18 @@ def nickname_decoder(bytes_from_psql: bytes | None) -> str:
 async def main() -> None:
     # It uses default connection parameters
     db_pool: Final = ConnectionPool()
-    connection: Connection = await db_pool.connection()
 
-    result: QueryResult = await connection.execute(
-        "SELECT * FROM for_test",
-        [CustomType(b"SomeDataInBytes")],
-    )
+    async with db_pool.acquire() as connection:
+        result: QueryResult = await connection.execute(
+            "SELECT * FROM for_test",
+            [CustomType(b"SomeDataInBytes")],
+        )
 
     parsed_result: list[dict[str, Any]] = result.result(
         custom_decoders={
             "nickname": nickname_decoder,
         },
     )
-    connection.close()
 ```
 
 ::: important

docs/usage/types/array_types.md

@@ -36,17 +36,17 @@ For type safety and better performance we have predefined array types.
 ### Example:
 
 ```python
-from psqlpy import Connection, ConnectionPool
+from psqlpy import ConnectionPool
 from psqlpy.extra_types import TextArray
 
 
 async def main() -> None:
     pool = ConnectionPool()
-    connection: Connection = await pool.connection()
-    result = await connection.execute(
-        querystring="SELECT * FROM users WHERE name = ANY($1)",
-        parameters=[
-            TextArray(["Alex", "Dev", "Who"]),
-        ]
-    )
+    async with db_pool.acquire() as connection:
+        result = await connection.execute(
+            querystring="SELECT * FROM users WHERE name = ANY($1)",
+            parameters=[
+                TextArray(["Alex", "Dev", "Who"]),
+            ]
+        )
 ```

docs/usage/types/extra_types.md

@@ -48,20 +48,18 @@ And we want to INSERT new data to this table:
 ```python
 from typing import Final
 
-from psqlpy import Connection, ConnectionPool, QueryResult
+from psqlpy import ConnectionPool, QueryResult
 from psqlpy.extra_types import SmallInt, Integer, BigInt, Float32, Float64
 
 
 async def main() -> None:
     # It uses default connection parameters
     db_pool: Final = ConnectionPool()
-    connection: Connection = await db_pool.connection()
-
-    await connection.execute(
-        "INSERT INTO numbers (index, elf_life, elon_musk_money) VALUES ($1, $2, $3, $4, $5)",
-        [SmallInt(101), Integer(10500), BigInt(300000000000), Float32(123.11), Float64(222.12)],
-    )
-    connection.close()
+    async with db_pool.acquire() as connection:
+        await connection.execute(
+            "INSERT INTO numbers (index, elf_life, elon_musk_money) VALUES ($1, $2, $3, $4, $5)",
+            [SmallInt(101), Integer(10500), BigInt(300000000000), Float32(123.11), Float64(222.12)],
+        )
 ```
 
 ::: important
@@ -82,25 +80,24 @@ Let's assume we have table `banners` in the database:
 ```python
 from typing import Final
 
-from psqlpy import Connection, ConnectionPool, QueryResult
+from psqlpy import ConnectionPool, QueryResult
 from psqlpy.extra_types import PyText
 
 
 async def main() -> None:
     # It uses default connection parameters
     db_pool: Final = ConnectionPool()
-    connection: Connection = await db_pool.connection()
-
-    await connection.execute(
-        "INSERT INTO banners (title, description) VALUES ($1, $2)",
-        ["SomeTitle", PyText("Very long description")],
-    )
-    # Alternatively, you can do this:
-    await connection.execute(
-        "INSERT INTO banners (title, description) VALUES ($1, $2)",
-        [PyVarChar("SomeTitle"), PyText("Very long description")],
-    )
-    connection.close()
+
+    async with db_pool.acquire() as connection:
+        await connection.execute(
+            "INSERT INTO banners (title, description) VALUES ($1, $2)",
+            ["SomeTitle", PyText("Very long description")],
+        )
+        # Alternatively, you can do this:
+        await connection.execute(
+            "INSERT INTO banners (title, description) VALUES ($1, $2)",
+            [PyVarChar("SomeTitle"), PyText("Very long description")],
+        )
 ```
 
 ## PyJSON & PyJSONB
@@ -128,15 +125,14 @@ Let's assume we have table `users` in the database, and field `additional_user_i
 ```python
 from typing import Final
 
-from psqlpy import Connection, ConnectionPool, QueryResult
+from psqlpy import ConnectionPool, QueryResult
 from psqlpy.extra_types import PyJSON
 
 
 async def main() -> None:
     # It uses default connection parameters
     db_pool: Final = ConnectionPool()
-    connection: Connection = await db_pool.connection()
-
+    
     list_for_jsonb_field = [
         {"some": "dict"},
         [
@@ -151,16 +147,15 @@ async def main() -> None:
         ]
     }
 
-    await connection.execute(
-        "INSERT INTO users (additional_user_info) VALUES ($1)",
-        [PyJSONB(list_for_jsonb_field)],
-    )
-    await connection.execute(
-        "INSERT INTO users (additional_user_info) VALUES ($1)",
-        [dict_for_jsonb_field,],
-    )
-
-    connection.close()
+    async with db_pool.acquire() as connection:
+        await connection.execute(
+            "INSERT INTO users (additional_user_info) VALUES ($1)",
+            [PyJSONB(list_for_jsonb_field)],
+        )
+        await connection.execute(
+            "INSERT INTO users (additional_user_info) VALUES ($1)",
+            [dict_for_jsonb_field,],
+        )
 ```
 
 ## PyMacAddr6 & PyMacAddr8
@@ -175,24 +170,22 @@ Let's assume we have table `devices` in the database:
 ```python
 from typing import Final
 
-from psqlpy import Connection, ConnectionPool, QueryResult
+from psqlpy import ConnectionPool, QueryResult
 from psqlpy.extra_types import PyMacAddr6, PyMacAddr8
 
 
 async def main() -> None:
     # It uses default connection parameters
     db_pool: Final = ConnectionPool()
-    connection: Connection = await db_pool.connection()
-
-    await connection.execute(
-        "INSERT INTO devices (device_macaddr6, device_macaddr8) VALUES ($1, $2)",
-        [
-            PyMacAddr6("08:00:2b:01:02:03"),
-            PyMacAddr8("08:00:2b:01:02:03:04:05"),
-        ],
-    )
-
-    connection.close()
+    
+    async with db_pool.acquire() as connection:
+        await connection.execute(
+            "INSERT INTO devices (device_macaddr6, device_macaddr8) VALUES ($1, $2)",
+            [
+                PyMacAddr6("08:00:2b:01:02:03"),
+                PyMacAddr8("08:00:2b:01:02:03:04:05"),
+            ],
+        )
 ```
 
 ## Geo Types
@@ -212,26 +205,24 @@ Let's assume we have table `geo_info` with all PostgreSQL geo types in the datab
 ```python
 from typing import Final
 
-from psqlpy import Connection, ConnectionPool, QueryResult
+from psqlpy import ConnectionPool, QueryResult
 from psqlpy.extra_types import Point, Box, Path, Line, LineSegment, Circle
 
 
 async def main() -> None:
     # It uses default connection parameters
     db_pool: Final = ConnectionPool()
-    connection: Connection = await db_pool.connection()
-
-    await connection.execute(
-        "INSERT INTO geo_info VALUES ($1, $2, $3, $4, $5, $6)",
-        [
-            Point([1.5, 2]),
-            Box([(1.7, 2.8), (9, 9)]),
-            Path([(3.5, 3), (9, 9), (8, 8)]),
-            Line([1, -2, 3]),
-            LineSegment([(5.6, 3.1), (4, 5)]),
-            Circle([5, 1.8, 10]),
-        ],
-    )
-
-    connection.close()
+    
+    async with db_pool.acquire() as connection:
+        await connection.execute(
+            "INSERT INTO geo_info VALUES ($1, $2, $3, $4, $5, $6)",
+            [
+                Point([1.5, 2]),
+                Box([(1.7, 2.8), (9, 9)]),
+                Path([(3.5, 3), (9, 9), (8, 8)]),
+                Line([1, -2, 3]),
+                LineSegment([(5.6, 3.1), (4, 5)]),
+                Circle([5, 1.8, 10]),
+            ],
+        )
 ```

docs/usage/types/supported_types.md

@@ -79,19 +79,19 @@ Now we can see what result will be returned.
 ```python
 from typing import Final
 
-from psqlpy import Connection, ConnectionPool, QueryResult
+from psqlpy import ConnectionPool, QueryResult
 from psqlpy.extra_types import SmallInt, Integer, BigInt
 
 
 async def main() -> None:
     # It uses default connection parameters
     db_pool: Final = ConnectionPool()
-    connection: Connection = await db_pool.connection()
-
-    result = await connection.execute(
-        "SELECT user_info FROM custom_table",
-    )
-    print(result.result()[0])
+    
+    async with db_pool.acquire() as connection:
+        result = await connection.execute(
+            "SELECT user_info FROM custom_table",
+        )
+        print(result.result()[0])
 ```
 It will return:
 ```json
@@ -122,7 +122,7 @@ Let's see how we can INSERT and SELECT such data.
 from enum import Enum
 from typing import Final
 
-from psqlpy import Connection, ConnectionPool, QueryResult
+from psqlpy import ConnectionPool, QueryResult
 
 
 class Weather(str, Enum):
@@ -133,23 +133,22 @@ class Weather(str, Enum):
 async def main() -> None:
     # It uses default connection parameters
     db_pool: Final = ConnectionPool()
-    connection: Connection = await db_pool.connection()
-
-    # Insert new data
-    await connection.execute(
-        querystring="INSERT INTO weather_plus VALUES($1)",
-        parameters=[Weather.SUN],
-    )
-
-    # Or you can pass string directly
-    await connection.execute(
-        querystring="INSERT INTO weather_plus VALUES($1)",
-        parameters=["sun"],
-    )
-
-    result = await connection.execute(
-        querystring="SELECT * FROM weather_plus",
-    )
+    async with db_pool.acquire() as connection:
+        # Insert new data
+        await connection.execute(
+            querystring="INSERT INTO weather_plus VALUES($1)",
+            parameters=[Weather.SUN],
+        )
+
+        # Or you can pass string directly
+        await connection.execute(
+            querystring="INSERT INTO weather_plus VALUES($1)",
+            parameters=["sun"],
+        )
+
+        result = await connection.execute(
+            querystring="SELECT * FROM weather_plus",
+        )
     print(result.result()[0])
 ```
 You will receive: