sql-athame 0.3.16__py3-none-any.whl → 0.4.0a2__py3-none-any.whl

sql_athame/base.py

@@ -106,14 +106,12 @@ class Fragment:
     @overload
     def prep_query(
         self, allow_slots: Literal[True]
-    ) -> Tuple[str, List[Union[Placeholder, Slot]]]:
-        ...  # pragma: no cover
+    ) -> Tuple[str, List[Union[Placeholder, Slot]]]: ...  # pragma: no cover
 
     @overload
     def prep_query(
         self, allow_slots: Literal[False] = False
-    ) -> Tuple[str, List[Placeholder]]:
-        ...  # pragma: no cover
+    ) -> Tuple[str, List[Placeholder]]: ...  # pragma: no cover
 
     def prep_query(self, allow_slots: bool = False) -> Tuple[str, List[Any]]:
         parts: List[FlatPart] = []
@@ -228,12 +226,10 @@ class SQLFormatter:
             return lit(f"{quote_identifier(name)}")
 
     @overload
-    def all(self, parts: Iterable[Fragment]) -> Fragment:
-        ...  # pragma: no cover
+    def all(self, parts: Iterable[Fragment]) -> Fragment: ...  # pragma: no cover
 
     @overload
-    def all(self, *parts: Fragment) -> Fragment:
-        ...  # pragma: no cover
+    def all(self, *parts: Fragment) -> Fragment: ...  # pragma: no cover
 
     def all(self, *parts) -> Fragment:  # type: ignore
         if parts and not isinstance(parts[0], Fragment):
@@ -241,12 +237,10 @@ class SQLFormatter:
         return any_all(list(parts), "AND", "TRUE")
 
     @overload
-    def any(self, parts: Iterable[Fragment]) -> Fragment:
-        ...  # pragma: no cover
+    def any(self, parts: Iterable[Fragment]) -> Fragment: ...  # pragma: no cover
 
     @overload
-    def any(self, *parts: Fragment) -> Fragment:
-        ...  # pragma: no cover
+    def any(self, *parts: Fragment) -> Fragment: ...  # pragma: no cover
 
     def any(self, *parts) -> Fragment:  # type: ignore
         if parts and not isinstance(parts[0], Fragment):
@@ -254,12 +248,10 @@ class SQLFormatter:
         return any_all(list(parts), "OR", "FALSE")
 
     @overload
-    def list(self, parts: Iterable[Fragment]) -> Fragment:
-        ...  # pragma: no cover
+    def list(self, parts: Iterable[Fragment]) -> Fragment: ...  # pragma: no cover
 
     @overload
-    def list(self, *parts: Fragment) -> Fragment:
-        ...  # pragma: no cover
+    def list(self, *parts: Fragment) -> Fragment: ...  # pragma: no cover
 
     def list(self, *parts) -> Fragment:  # type: ignore
         if parts and not isinstance(parts[0], Fragment):

sql_athame/dataclasses.py

@@ -54,7 +54,7 @@ def model_field_metadata(
 def model_field(
     *, type: str, constraints: Union[str, Iterable[str]] = (), **kwargs: Any
 ) -> Any:
-    return field(**kwargs, metadata=model_field_metadata(type, constraints))  # type: ignore
+    return field(**kwargs, metadata=model_field_metadata(type, constraints))
 
 
 sql_create_type_map = {
@@ -100,17 +100,36 @@ class ModelBase(Mapping[str, Any]):
     _cache: Dict[tuple, Any]
     table_name: str
     primary_key_names: Tuple[str, ...]
+    array_safe_insert: bool
 
     def __init_subclass__(
-        cls, *, table_name: str, primary_key: Union[FieldNames, str] = (), **kwargs: Any
+        cls,
+        *,
+        table_name: str,
+        primary_key: Union[FieldNames, str] = (),
+        insert_multiple_mode: str = "unnest",
+        **kwargs: Any,
     ):
         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:
+            raise ValueError("Unknown `insert_multiple_mode`")
         if isinstance(primary_key, str):
             cls.primary_key_names = (primary_key,)
         else:
             cls.primary_key_names = tuple(primary_key)
 
+    @classmethod
+    def _fields(cls):
+        # wrapper to ignore typing weirdness: 'Argument 1 to "fields"
+        # has incompatible type "..."; expected "DataclassInstance |
+        # type[DataclassInstance]"'
+        return fields(cls)  # type: ignore
+
     @classmethod
     def _cached(cls, key: tuple, thunk: Callable[[], U]) -> U:
         try:
@@ -139,7 +158,7 @@ class ModelBase(Mapping[str, Any]):
         try:
             return cls._column_info[column]  # type: ignore
         except AttributeError:
-            cls._column_info = {f.name: column_info_for_field(f) for f in fields(cls)}
+            cls._column_info = {f.name: column_info_for_field(f) for f in cls._fields()}
             return cls._column_info[column]
 
     @classmethod
@@ -152,7 +171,7 @@ class ModelBase(Mapping[str, Any]):
 
     @classmethod
     def field_names(cls, *, exclude: FieldNamesSet = ()) -> List[str]:
-        return [f.name for f in fields(cls) if f.name not in exclude]
+        return [f.name for f in cls._fields() if f.name not in exclude]
 
     @classmethod
     def field_names_sql(
@@ -171,7 +190,7 @@ class ModelBase(Mapping[str, Any]):
     ) -> Callable[[T], List[Any]]:
         env: Dict[str, Any] = dict()
         func = ["def get_field_values(self): return ["]
-        for f in fields(cls):
+        for f in cls._fields():
             if f.name not in exclude:
                 func.append(f"self.{f.name},")
         func += ["]"]
@@ -200,23 +219,23 @@ class ModelBase(Mapping[str, Any]):
     def from_tuple(
         cls: Type[T], tup: tuple, *, offset: int = 0, exclude: FieldNamesSet = ()
     ) -> T:
-        names = (f.name for f in fields(cls) if f.name not in exclude)
+        names = (f.name for f in cls._fields() if f.name not in exclude)
         kwargs = {name: tup[offset] for offset, name in enumerate(names, start=offset)}
-        return cls(**kwargs)  # type: ignore
+        return cls(**kwargs)
 
     @classmethod
     def from_dict(
         cls: Type[T], dct: Dict[str, Any], *, exclude: FieldNamesSet = ()
     ) -> T:
-        names = {f.name for f in fields(cls) if f.name not in exclude}
+        names = {f.name for f in cls._fields() if f.name not in exclude}
         kwargs = {k: v for k, v in dct.items() if k in names}
-        return cls(**kwargs)  # type: ignore
+        return cls(**kwargs)
 
     @classmethod
     def ensure_model(cls: Type[T], row: Union[T, Mapping[str, Any]]) -> T:
         if isinstance(row, cls):
             return row
-        return cls(**row)  # type: ignore
+        return cls(**row)
 
     @classmethod
     def create_table_sql(cls) -> Fragment:
@@ -226,7 +245,7 @@ class ModelBase(Mapping[str, Any]):
                 sql.identifier(f.name),
                 sql.literal(cls.column_info(f.name).create_table_string()),
             )
-            for f in fields(cls)
+            for f in cls._fields()
         ]
         if cls.primary_key_names:
             entries += [sql("PRIMARY KEY ({})", sql.list(cls.primary_key_names_sql()))]
@@ -278,7 +297,7 @@ class ModelBase(Mapping[str, Any]):
             *cls.select_sql(order_by=order_by, for_update=for_update, where=where),
             prefetch=prefetch,
         ):
-            yield cls(**row)  # type: ignore
+            yield cls(**row)
 
     @classmethod
     async def select(
@@ -289,7 +308,7 @@ class ModelBase(Mapping[str, Any]):
         where: Where = (),
     ) -> List[T]:
         return [
-            cls(**row)  # type: ignore
+            cls(**row)
             for row in await connection_or_pool.fetch(
                 *cls.select_sql(order_by=order_by, for_update=for_update, where=where)
             )
@@ -310,7 +329,7 @@ class ModelBase(Mapping[str, Any]):
         cls: Type[T], connection_or_pool: Union[Connection, Pool], **kwargs: Any
     ) -> T:
         row = await connection_or_pool.fetchrow(*cls.create_sql(**kwargs))
-        return cls(**row)  # type: ignore
+        return cls(**row)
 
     def insert_sql(self, exclude: FieldNamesSet = ()) -> Fragment:
         cached = self._cached(
@@ -400,26 +419,76 @@ class ModelBase(Mapping[str, Any]):
         )
 
     @classmethod
-    async def insert_multiple(
+    def insert_multiple_array_safe_sql(cls: Type[T], rows: Iterable[T]) -> Fragment:
+        return sql(
+            "INSERT INTO {table} ({fields}) VALUES {values}",
+            table=cls.table_name_sql(),
+            fields=sql.list(cls.field_names_sql()),
+            values=sql.list(
+                sql("({})", sql.list(row.field_values_sql(default_none=True)))
+                for row in rows
+            ),
+        )
+
+    @classmethod
+    async def insert_multiple_unnest(
         cls: Type[T], connection_or_pool: Union[Connection, Pool], rows: Iterable[T]
     ) -> str:
         return await connection_or_pool.execute(*cls.insert_multiple_sql(rows))
 
     @classmethod
-    async def upsert_multiple(
+    async def insert_multiple_array_safe(
+        cls: Type[T], connection_or_pool: Union[Connection, Pool], rows: Iterable[T]
+    ) -> str:
+        for chunk in chunked(rows, 100):
+            last = await connection_or_pool.execute(
+                *cls.insert_multiple_array_safe_sql(chunk)
+            )
+        return last
+
+    @classmethod
+    async def insert_multiple(
+        cls: Type[T], connection_or_pool: Union[Connection, Pool], rows: Iterable[T]
+    ) -> str:
+        if cls.array_safe_insert:
+            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_unnest(
         cls: Type[T], connection_or_pool: Union[Connection, Pool], rows: Iterable[T]
     ) -> str:
         return await connection_or_pool.execute(
             *cls.upsert_sql(cls.insert_multiple_sql(rows))
         )
 
+    @classmethod
+    async def upsert_multiple_array_safe(
+        cls: Type[T], connection_or_pool: Union[Connection, Pool], rows: Iterable[T]
+    ) -> str:
+        for chunk in chunked(rows, 100):
+            last = await connection_or_pool.execute(
+                *cls.upsert_sql(cls.insert_multiple_array_safe_sql(chunk))
+            )
+        return last
+
+    @classmethod
+    async def upsert_multiple(
+        cls: Type[T], connection_or_pool: Union[Connection, Pool], rows: Iterable[T]
+    ) -> str:
+        if cls.array_safe_insert:
+            return await cls.upsert_multiple_array_safe(connection_or_pool, rows)
+        else:
+            return await cls.upsert_multiple_unnest(connection_or_pool, rows)
+
     @classmethod
     def _get_equal_ignoring_fn(
         cls: Type[T], ignore: FieldNamesSet = ()
     ) -> Callable[[T, T], bool]:
         env: Dict[str, Any] = dict()
         func = ["def equal_ignoring(a, b):"]
-        for f in fields(cls):
+        for f in cls._fields():
             if f.name not in ignore:
                 func.append(f" if a.{f.name} != b.{f.name}: return False")
         func += [" return True"]
@@ -473,7 +542,7 @@ class ModelBase(Mapping[str, Any]):
             "def differences_ignoring(a, b):",
             " diffs = []",
         ]
-        for f in fields(cls):
+        for f in cls._fields():
             if f.name not in ignore:
                 func.append(
                     f" if a.{f.name} != b.{f.name}: diffs.append({repr(f.name)})"
@@ -523,3 +592,8 @@ class ModelBase(Mapping[str, Any]):
             await cls.delete_multiple(connection, deleted)
 
         return created, updated_triples, deleted
+
+
+def chunked(lst, n):
+    for i in range(0, len(lst), n):
+        yield lst[i : i + n]

sql_athame/sqlalchemy.py

@@ -27,7 +27,6 @@ try:
         query = "".join(out_parts).strip()
         return text(query).bindparams(*bindparams.values())
 
-
 except ImportError:
 
     def sqlalchemy_text_from_fragment(self: "Fragment") -> Any:

{sql_athame-0.3.16.dist-info → sql_athame-0.4.0a2.dist-info}/METADATA

@@ -1,19 +1,20 @@
 Metadata-Version: 2.1
 Name: sql-athame
-Version: 0.3.16
+Version: 0.4.0a2
 Summary: Python tool for slicing and dicing SQL
 Home-page: https://github.com/bdowning/sql-athame
 License: MIT
 Author: Brian Downing
 Author-email: bdowning@lavos.net
-Requires-Python: >=3.7,<4.0
+Requires-Python: >=3.9,<4.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
 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"
+Requires-Dist: asyncpg ; extra == "asyncpg"
 Requires-Dist: typing-extensions
 Project-URL: Repository, https://github.com/bdowning/sql-athame
 Description-Content-Type: text/markdown

sql_athame-0.4.0a2.dist-info/RECORD

@@ -0,0 +1,11 @@
+sql_athame/__init__.py,sha256=rzUQcbzmj3qkPZpL9jI_ALTRv-e1pAV4jSCryWkutlk,130
+sql_athame/base.py,sha256=fSnHQhh5ULeJ5q32RVUAvpWtF0qoY61B2gEEP59Nrpo,10350
+sql_athame/dataclasses.py,sha256=oo1NnUrd-THKVRtTnAK08P4UnFIUBsVJHrOO5tgfi_I,19697
+sql_athame/escape.py,sha256=LXExbiYtc407yDU4vPieyY2Pq5nypsJFfBc_2-gsbUg,743
+sql_athame/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sql_athame/sqlalchemy.py,sha256=c-pCLE11hTh5I19rY1Vp5E7P7lAaj9i-i7ko2L8rlF4,1305
+sql_athame/types.py,sha256=7P4OyY0ezRlb2UDD9lpdXiLChnhQcBvHWaG_PKy3jmE,412
+sql_athame-0.4.0a2.dist-info/LICENSE,sha256=xqV29vPFqITcKifYrGPgVIBjq4fdmLSwY3gRUtDKafg,1076
+sql_athame-0.4.0a2.dist-info/METADATA,sha256=_2r7ZYOb5St8muq7EnfoiNEQJA1eskEibMjn7JHkcxI,12845
+sql_athame-0.4.0a2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+sql_athame-0.4.0a2.dist-info/RECORD,,

{sql_athame-0.3.16.dist-info → sql_athame-0.4.0a2.dist-info}/WHEEL

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

sql_athame-0.3.16.dist-info/RECORD

@@ -1,11 +0,0 @@
-sql_athame/__init__.py,sha256=rzUQcbzmj3qkPZpL9jI_ALTRv-e1pAV4jSCryWkutlk,130
-sql_athame/base.py,sha256=JIe2oUtADAuF1wAsrK2-VoA8ZbcXIECMNEamdd7f8-Y,10414
-sql_athame/dataclasses.py,sha256=d_QRwLulhxtRKtOlUkjuBcMYv_Zd2ioWLr8y-yP2GJ4,17208
-sql_athame/escape.py,sha256=LXExbiYtc407yDU4vPieyY2Pq5nypsJFfBc_2-gsbUg,743
-sql_athame/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sql_athame/sqlalchemy.py,sha256=3ivXs3GqoGebJig20XIaCZQcdccB-dOrLVq2uztIpb8,1306
-sql_athame/types.py,sha256=7P4OyY0ezRlb2UDD9lpdXiLChnhQcBvHWaG_PKy3jmE,412
-sql_athame-0.3.16.dist-info/LICENSE,sha256=xqV29vPFqITcKifYrGPgVIBjq4fdmLSwY3gRUtDKafg,1076
-sql_athame-0.3.16.dist-info/WHEEL,sha256=V7iVckP-GYreevsTDnv1eAinQt_aArwnAxmnP0gygBY,83
-sql_athame-0.3.16.dist-info/METADATA,sha256=9gdIZYfTND8xXnu0-5LaEYE5KdlvtNrO5Fu7TELIbjo,12790
-sql_athame-0.3.16.dist-info/RECORD,,