sql-athame 0.4.0a10__py3-none-any.whl → 0.4.0a11__py3-none-any.whl

sql_athame/dataclasses.py

@@ -157,7 +157,7 @@ class ModelBase:
     _cache: dict[tuple, Any]
     table_name: str
     primary_key_names: tuple[str, ...]
-    array_safe_insert: bool
+    insert_multiple_mode: str
 
     def __init_subclass__(
         cls,
@@ -169,12 +169,9 @@ class ModelBase:
     ):
         cls._cache = {}
         cls.table_name = table_name
-        if insert_multiple_mode == "array_safe":
-            cls.array_safe_insert = True
-        elif insert_multiple_mode == "unnest":
-            cls.array_safe_insert = False
-        else:
+        if insert_multiple_mode not in ("array_safe", "unnest", "executemany"):
             raise ValueError("Unknown `insert_multiple_mode`")
+        cls.insert_multiple_mode = insert_multiple_mode
         if isinstance(primary_key, str):
             cls.primary_key_names = (primary_key,)
         else:
@@ -357,7 +354,17 @@ class ModelBase:
         return query
 
     @classmethod
-    async def select_cursor(
+    async def cursor_from(
+        cls: type[T],
+        connection: Connection,
+        query: Fragment,
+        prefetch: int = 1000,
+    ) -> AsyncGenerator[T, None]:
+        async for row in connection.cursor(*query, prefetch=prefetch):
+            yield cls.from_mapping(row)
+
+    @classmethod
+    def select_cursor(
         cls: type[T],
         connection: Connection,
         order_by: Union[FieldNames, str] = (),
@@ -365,11 +372,19 @@ class ModelBase:
         where: Where = (),
         prefetch: int = 1000,
     ) -> AsyncGenerator[T, None]:
-        async for row in connection.cursor(
-            *cls.select_sql(order_by=order_by, for_update=for_update, where=where),
+        return cls.cursor_from(
+            connection,
+            cls.select_sql(order_by=order_by, for_update=for_update, where=where),
             prefetch=prefetch,
-        ):
-            yield cls.from_mapping(row)
+        )
+
+    @classmethod
+    async def fetch_from(
+        cls: type[T],
+        connection_or_pool: Union[Connection, Pool],
+        query: Fragment,
+    ) -> list[T]:
+        return [cls.from_mapping(row) for row in await connection_or_pool.fetch(*query)]
 
     @classmethod
     async def select(
@@ -379,12 +394,10 @@ class ModelBase:
         for_update: bool = False,
         where: Where = (),
     ) -> list[T]:
-        return [
-            cls.from_mapping(row)
-            for row in await connection_or_pool.fetch(
-                *cls.select_sql(order_by=order_by, for_update=for_update, where=where)
-            )
-        ]
+        return await cls.fetch_from(
+            connection_or_pool,
+            cls.select_sql(order_by=order_by, for_update=for_update, where=where),
+        )
 
     @classmethod
     def create_sql(cls: type[T], **kwargs: Any) -> Fragment:
@@ -506,6 +519,37 @@ class ModelBase:
             ),
         )
 
+    @classmethod
+    def insert_multiple_executemany_chunk_sql(
+        cls: type[T], chunk_size: int
+    ) -> Fragment:
+        def generate() -> Fragment:
+            columns = len(cls.column_info())
+            values = ", ".join(
+                f"({', '.join(f'${i}' for i in chunk)})"
+                for chunk in chunked(range(1, columns * chunk_size + 1), columns)
+            )
+            return sql(
+                "INSERT INTO {table} ({fields}) VALUES {values}",
+                table=cls.table_name_sql(),
+                fields=sql.list(cls.field_names_sql()),
+                values=sql.literal(values),
+            ).flatten()
+
+        return cls._cached(
+            ("insert_multiple_executemany_chunk", chunk_size),
+            generate,
+        )
+
+    @classmethod
+    async def insert_multiple_executemany(
+        cls: type[T], connection_or_pool: Union[Connection, Pool], rows: Iterable[T]
+    ) -> None:
+        args = [r.field_values() for r in rows]
+        query = cls.insert_multiple_executemany_chunk_sql(1).query()[0]
+        if args:
+            await connection_or_pool.executemany(query, args)
+
     @classmethod
     async def insert_multiple_unnest(
         cls: type[T], connection_or_pool: Union[Connection, Pool], rows: Iterable[T]
@@ -527,11 +571,28 @@ class ModelBase:
     async def insert_multiple(
         cls: type[T], connection_or_pool: Union[Connection, Pool], rows: Iterable[T]
     ) -> str:
-        if cls.array_safe_insert:
+        if cls.insert_multiple_mode == "executemany":
+            await cls.insert_multiple_executemany(connection_or_pool, rows)
+            return "INSERT"
+        elif cls.insert_multiple_mode == "array_safe":
             return await cls.insert_multiple_array_safe(connection_or_pool, rows)
         else:
             return await cls.insert_multiple_unnest(connection_or_pool, rows)
 
+    @classmethod
+    async def upsert_multiple_executemany(
+        cls: type[T],
+        connection_or_pool: Union[Connection, Pool],
+        rows: Iterable[T],
+        insert_only: FieldNamesSet = (),
+    ) -> None:
+        args = [r.field_values() for r in rows]
+        query = cls.upsert_sql(
+            cls.insert_multiple_executemany_chunk_sql(1), exclude=insert_only
+        ).query()[0]
+        if args:
+            await connection_or_pool.executemany(query, args)
+
     @classmethod
     async def upsert_multiple_unnest(
         cls: type[T],
@@ -566,7 +627,12 @@ class ModelBase:
         rows: Iterable[T],
         insert_only: FieldNamesSet = (),
     ) -> str:
-        if cls.array_safe_insert:
+        if cls.insert_multiple_mode == "executemany":
+            await cls.upsert_multiple_executemany(
+                connection_or_pool, rows, insert_only=insert_only
+            )
+            return "INSERT"
+        elif cls.insert_multiple_mode == "array_safe":
             return await cls.upsert_multiple_array_safe(
                 connection_or_pool, rows, insert_only=insert_only
             )

{sql_athame-0.4.0a10.dist-info → sql_athame-0.4.0a11.dist-info}/METADATA

@@ -1,22 +1,16 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: sql-athame
-Version: 0.4.0a10
+Version: 0.4.0a11
 Summary: Python tool for slicing and dicing SQL
-Home-page: https://github.com/bdowning/sql-athame
+Project-URL: homepage, https://github.com/bdowning/sql-athame
+Project-URL: repository, https://github.com/bdowning/sql-athame
+Author-email: Brian Downing <bdowning@lavos.net>
 License: MIT
-Author: Brian Downing
-Author-email: bdowning@lavos.net
-Requires-Python: >=3.9,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Provides-Extra: asyncpg
-Requires-Dist: asyncpg ; extra == "asyncpg"
+License-File: LICENSE
+Requires-Python: <4.0,>=3.9
 Requires-Dist: typing-extensions
-Project-URL: Repository, https://github.com/bdowning/sql-athame
+Provides-Extra: asyncpg
+Requires-Dist: asyncpg; extra == 'asyncpg'
 Description-Content-Type: text/markdown
 
 # sql-athame
@@ -405,4 +399,3 @@ MIT.
 
 ---
 Copyright (c) 2019, 2020 Brian Downing
-

{sql_athame-0.4.0a10.dist-info → sql_athame-0.4.0a11.dist-info}/RECORD

@@ -1,11 +1,11 @@
 sql_athame/__init__.py,sha256=0GA9-xfnZ_gw7Vysx6t4iInQ2kGXos1EYwBI6Eb7auU,100
 sql_athame/base.py,sha256=FR7EmC0VkX1VRgvAutSEfYSWhlEYpoqS1Kqxp1jHp6Y,10293
-sql_athame/dataclasses.py,sha256=7qjAYP_dAD3hY_3txchBJfI5gURGmunOha6dDJdQjjw,25018
+sql_athame/dataclasses.py,sha256=0XjLXpSBgdtWqJkTdaluLs8_RXPlfJp5ERKGOe-bXBM,27442
 sql_athame/escape.py,sha256=kK101xXeFitlvuG-L_hvhdpgGJCtmRTprsn1yEfZKws,758
 sql_athame/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sql_athame/sqlalchemy.py,sha256=aWopfPh3j71XwKmcN_VcHRNlhscI0Sckd4AiyGf8Tpw,1293
 sql_athame/types.py,sha256=FQ06l9Uc-vo57UrAarvnukILdV2gN1IaYUnHJ_bNYic,475
-sql_athame-0.4.0a10.dist-info/LICENSE,sha256=xqV29vPFqITcKifYrGPgVIBjq4fdmLSwY3gRUtDKafg,1076
-sql_athame-0.4.0a10.dist-info/METADATA,sha256=NU7Rhvp11MdZYD3YWtHJpauGOq8Nal8-cBa2EsMR0vE,12846
-sql_athame-0.4.0a10.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-sql_athame-0.4.0a10.dist-info/RECORD,,
+sql_athame-0.4.0a11.dist-info/METADATA,sha256=DXasc1ZenA7rqqTPu0G0Y1dfFEGmzngZGhAnUxGJAcs,12570
+sql_athame-0.4.0a11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sql_athame-0.4.0a11.dist-info/licenses/LICENSE,sha256=xqV29vPFqITcKifYrGPgVIBjq4fdmLSwY3gRUtDKafg,1076
+sql_athame-0.4.0a11.dist-info/RECORD,,

{sql_athame-0.4.0a10.dist-info → sql_athame-0.4.0a11.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any