sql-athame 0.4.0a10__py3-none-any.whl → 0.4.0a12__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:
@@ -233,8 +230,21 @@ class ModelBase:
 
     @classmethod
     def field_names_sql(
-        cls, *, prefix: Optional[str] = None, exclude: FieldNamesSet = ()
+        cls,
+        *,
+        prefix: Optional[str] = None,
+        exclude: FieldNamesSet = (),
+        as_prepended: Optional[str] = None,
     ) -> list[Fragment]:
+        if as_prepended:
+            return [
+                sql(
+                    "{} AS {}",
+                    sql.identifier(f, prefix=prefix),
+                    sql.identifier(f"{as_prepended}{f}"),
+                )
+                for f in cls.field_names(exclude=exclude)
+            ]
         return [
             sql.identifier(f, prefix=prefix) for f in cls.field_names(exclude=exclude)
         ]
@@ -303,6 +313,16 @@ class ModelBase:
         cls.from_mapping = from_mapping_fn  # type: ignore
         return from_mapping_fn(mapping)
 
+    @classmethod
+    def from_prepended_mapping(
+        cls: type[T], mapping: Mapping[str, Any], prepend: str
+    ) -> T:
+        filtered_dict: dict[str, Any] = {}
+        for k, v in mapping.items():
+            if k.startswith(prepend):
+                filtered_dict[k[len(prepend) :]] = v
+        return cls.from_mapping(filtered_dict)
+
     @classmethod
     def ensure_model(cls: type[T], row: Union[T, Mapping[str, Any]]) -> T:
         if isinstance(row, cls):
@@ -357,7 +377,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 +395,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 +417,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 +542,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 +594,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 +650,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.0a12.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.0a12
 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
@@ -404,5 +398,4 @@ TODO, for now read the [source](sql_athame/dataclasses.py).
 MIT.
 
 ---
-Copyright (c) 2019, 2020 Brian Downing
-
+Copyright (c) 2019–2025 Brian Downing

{sql_athame-0.4.0a10.dist-info → sql_athame-0.4.0a12.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=rqobdKMHEohVJknEj6Vv2UzihgOttaROEhnwuO6G4LQ,28155
 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.0a12.dist-info/METADATA,sha256=kBYRXE0MC2W8jGbX3NqZpDvOeBKxqnu-vlAKCx5ka5o,12571
+sql_athame-0.4.0a12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sql_athame-0.4.0a12.dist-info/licenses/LICENSE,sha256=kPtZhuBL-A3tMrge4oz5bm_Di2M8KcA-sJY7abTEfZ4,1075
+sql_athame-0.4.0a12.dist-info/RECORD,,

{sql_athame-0.4.0a10.dist-info → sql_athame-0.4.0a12.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

{sql_athame-0.4.0a10.dist-info → sql_athame-0.4.0a12.dist-info/licenses}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019, 2020 Brian Downing
+Copyright (c) 2019-2025 Brian Downing
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal