sql-athame 0.3.16__tar.gz → 0.4.0a2__tar.gz

{sql-athame-0.3.16 → sql_athame-0.4.0a2}/PKG-INFO

@@ -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.3.16 → sql_athame-0.4.0a2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "sql-athame"
-version = "0.3.16"
+version = "0.4.0-alpha-2"
 description = "Python tool for slicing and dicing SQL"
 authors = ["Brian Downing <bdowning@lavos.net>"]
 license = "MIT"
@@ -12,12 +12,12 @@ repository = "https://github.com/bdowning/sql-athame"
 asyncpg = ["asyncpg"]
 
 [tool.poetry.dependencies]
-python = "^3.7"
+python = "^3.9"
 asyncpg = { version = "*", optional = true }
 typing-extensions = "*"
 
 [tool.poetry.dev-dependencies]
-black = {version = "*", allow-prereleases = true}
+black = "*"
 isort = "*"
 pytest = "*"
 mypy = "*"

{sql-athame-0.3.16 → sql_athame-0.4.0a2}/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-0.3.16 → sql_athame-0.4.0a2}/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-0.3.16 → sql_athame-0.4.0a2}/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/setup.py

@@ -1,34 +0,0 @@
-# -*- coding: utf-8 -*-
-from setuptools import setup
-
-packages = \
-['sql_athame']
-
-package_data = \
-{'': ['*']}
-
-install_requires = \
-['typing-extensions']
-
-extras_require = \
-{'asyncpg': ['asyncpg']}
-
-setup_kwargs = {
-    'name': 'sql-athame',
-    'version': '0.3.16',
-    'description': 'Python tool for slicing and dicing SQL',
-    'long_description': '# sql-athame\n\nPython tool for slicing and dicing SQL.  Its intended target is\nPostgres with _asyncpg_, though it also includes support for rendering\nto a SQLAlchemy `TextClause`.\n\n## Base query builder\n\n### Example\n\n```python\nfrom sql_athame import sql\n\n\ndef get_orders(query):\n    where = []\n\n    if "id" in query:\n        where.append(sql("id = {}", query["id"]))\n    if "eventId" in query:\n        where.append(sql("event_id = {}", query["eventId"]))\n    if "startTime" in query:\n        where.append(sql("start_time = {}", query["startTime"]))\n    if "from" in query:\n        where.append(sql("start_time >= {}", query["from"]))\n    if "until" in query:\n        where.append(sql("start_time < {}", query["until"]))\n\n    return sql("SELECT * FROM orders WHERE {}", sql.all(where))\n\n\n>>> list(get_orders({}))\n[\'SELECT * FROM orders WHERE TRUE\']\n\n>>> list(get_orders({"id": "xyzzy"}))\n[\'SELECT * FROM orders WHERE (id = $1)\', \'xyzzy\']\n\n>>> list(get_orders({"eventId": "plugh", "from": "2019-05-01", "until": "2019-08-26"}))\n[\'SELECT * FROM orders WHERE (event_id = $1) AND (start_time >= $2) AND (start_time < $3)\',\n \'plugh\',\n \'2019-05-01\',\n \'2019-08-26\']\n\n\nsuperquery = sql(\n    """\n    SELECT *\n      FROM ({subquery}) sq\n      JOIN other_table ot ON (ot.id = sq.id)\n      WHERE ot.foo = {foo}\n      LIMIT {limit}\n    """,\n    subquery=get_orders({"id": "xyzzy"}),\n    foo="bork",\n    limit=50,\n)\n\n\n>>> list(superquery)\n[\'SELECT * FROM (SELECT * FROM orders WHERE (id = $1)) sq JOIN other_table ot ON (ot.id = sq.id) WHERE ot.foo = $2 LIMIT $3\',\n \'xyzzy\',\n \'bork\',\n 50]\n```\n\n### API reference\n\n```python\nfrom sql_athame import sql\n```\n\n#### sql(fmt: str, \\*args, \\*\\*kwargs) -> Fragment\n\nCreates a SQL `Fragment` from the `fmt` string.  The `fmt` string\ncontains literal SQL and may contain positional references, marked by\n`{}`, and named references, marked by `{name}`.  Positional references\n_must_ have a matching argument in `*args`.  Named references _may_\nhave a matching argument in `**kwargs`; if a named reference is not\nfullfilled by `**kwargs` it remains as a named _slot_ to be filled\nlater.\n\nIf a referenced argument is a `Fragment`, it is substituted into the\nSQL along with all of its embedded placeholders if any.  Otherwise, it\nis treated as a placeholder value and substituted in place as a\nplaceholder.\n\n#### Fragment.query(self) -> Tuple[str, List[Any]]\n\nRenders a SQL `Fragment` into a query string and list of placeholder\nparameters.\n\n```python\n>>> q = sql("SELECT * FROM tbl WHERE qty > {qty}", qty=10)\n>>> q.query()\n(\'SELECT * FROM tbl WHERE qty > $1\', [10])\n```\n\nIf there are any unfilled _slots_ `ValueError` will be raised.\n\n```python\n>>> q = sql("SELECT * FROM tbl WHERE qty > {qty}")\n>>> q.query()\nValueError: Unfilled slot: \'qty\'\n>>> q.fill(qty=10).query()\n(\'SELECT * FROM tbl WHERE qty > $1\', [10])\n```\n\n#### Fragment.\\_\\_iter\\_\\_(self) -> Iterator[Any]\n\nA `Fragment` is an iterable which will return the query string\nfollowed by the placeholder parameters as returned by\n`Fragment.query(self)`.  This matches the `(query, *args)` argument\npattern of the _asyncpg_ API:\n\n```python\nq = sql("SELECT * FROM tbl WHERE qty > {}", 10)\nawait conn.fetch(*q)\n```\n\n#### sql.list(parts: Iterable[Fragment]) -> Fragment\n#### sql.list(*parts: Fragment) -> Fragment\n\nCreates a SQL `Fragment` joining the fragments in `parts` together\nwith commas.\n\n```python\n>>> cols = [sql("a"), sql("b"), sql("c")]\n>>> list(sql("SELECT {cols} FROM tbl", cols=sql.list(cols)))\n[\'SELECT a, b, c FROM tbl\']\n```\n\n#### sql.all(parts: Iterable[Fragment]) -> Fragment\n#### sql.all(*parts: Fragment) -> Fragment\n\nCreates a SQL `Fragment` joining the fragments in `parts` together\nwith `AND`.  If `parts` is empty, returns `TRUE`.\n\n```python\n>>> where = [sql("a = {}", 42), sql("x <> {}", "foo")]\n>>> list(sql("SELECT * FROM tbl WHERE {}", sql.all(where)))\n[\'SELECT * FROM tbl WHERE (a = $1) AND (x <> $2)\', 42, \'foo\']\n>>> list(sql("SELECT * FROM tbl WHERE {}", sql.all([])))\n[\'SELECT * FROM tbl WHERE TRUE\']\n```\n\n#### sql.any(parts: Iterable[Fragment]) -> Fragment\n#### sql.any(*parts: Fragment) -> Fragment\n\nCreates a SQL `Fragment` joining the fragments in `parts` together\nwith `OR`.  If `parts` is empty, returns `FALSE`.\n\n```python\n>>> where = [sql("a = {}", 42), sql("x <> {}", "foo")]\n>>> list(sql("SELECT * FROM tbl WHERE {}", sql.any(where)))\n[\'SELECT * FROM tbl WHERE (a = $1) OR (x <> $2)\', 42, \'foo\']\n>>> list(sql("SELECT * FROM tbl WHERE {}", sql.any([])))\n[\'SELECT * FROM tbl WHERE FALSE\']\n```\n\n#### Fragment.join(self, parts: Iterable[Fragment]) -> Fragment\n\nCreates a SQL `Fragment` by joining the fragments in `parts` together\nwith `self`.\n\n```python\n>>> clauses = [sql("WHEN {} THEN {}", a, b) for a, b in ((sql("a"), 1), (sql("b"), 2))]\n>>> case = sql("CASE {clauses} END", clauses=sql(" ").join(clauses))\n>>> list(case)\n[\'CASE WHEN a THEN $1 WHEN b THEN $2 END\', 1, 2]\n```\n\n#### sql.literal(text: str) -> Fragment\n\nCreates a SQL `Fragment` with the literal SQL `text`.  No substitution\nof any kind is performed.  **Be very careful of SQL injection.**\n\n#### sql.identifier(name: str, prefix: Optional[str] = None) -> Fragment\n\nCreates a SQL `Fragment` with a quoted identifier name, optionally\nwith a dotted prefix.\n\n```python\n>>> list(sql("SELECT {a} FROM tbl", a=sql.identifier("a", prefix="tbl")))\n[\'SELECT "tbl"."a" FROM tbl\']\n```\n\n#### sql.value(value: Any) -> Fragment\n\nCreates a SQL `Fragment` with a single placeholder to `value`.\nEquivalent to:\n\n```python\nsql("{}", value)\n```\n\n#### sql.escape(value: Any) -> Fragment\n\nCreates a SQL `Fragment` with `value` escaped and embedded into the\nSQL.  Types currently supported are strings, floats, ints, UUIDs,\n`None`, and sequences of the above.\n\n```python\n>>> list(sql("SELECT * FROM tbl WHERE qty = ANY({})", sql.escape([1, 3, 5])))\n[\'SELECT * FROM tbl WHERE qty = ANY(ARRAY[1, 3, 5])\']\n```\n\nCompare to with a placeholder:\n\n```python\n>>> list(sql("SELECT * FROM tbl WHERE qty = ANY({})", [1, 3, 5]))\n[\'SELECT * FROM tbl WHERE qty = ANY($1)\', [1, 3, 5]]\n```\n\n"Burning" an invariant value into the query can potentially help the\nquery optimizer.\n\n#### sql.slot(name: str) -> Fragment\n\nCreates a SQL `Fragment` with a single empty _slot_ named `name`.\nEquivalent to:\n\n```python\nsql("{name}")\n```\n\n#### sql.unnest(data: Iterable[Sequence[Any]], types: Iterable[str]) -> Fragment\n\nCreates a SQL `Fragment` containing an `UNNEST` expression with\nassociated data.\n\nThe data is specified in tuples (in the "several database columns"\nsense, not necessarily the Python sense) in `data`, and the tuple\nPostgres types must be specified in `types`.  The data is transposed\ninto the correct form for `UNNEST` and embedded in placeholders in the\n`Fragment`.\n\n```python\n>>> list(sql("SELECT * FROM {}", sql.unnest([("a", 1), ("b", 2), ("c", 3)], ["text", "integer"])))\n[\'SELECT * FROM UNNEST($1::text[], $2::integer[])\', (\'a\', \'b\', \'c\'), (1, 2, 3)]\n```\n\n#### Fragment.fill(self, \\*\\*kwargs) -> Fragment\n\nCreates a SQL `Fragment` by filling any empty _slots_ in `self` with\n`kwargs`.  Similar to `sql` subtitution, if a value is a `Fragment` it\nis substituted in-place, otherwise it is substituted as a placeholder.\n\n#### Fragment.compile(self) -> Callable[..., Fragment]\n\nCreates a function that when called with `**kwargs` will create a SQL\n`Fragment` equivalent to calling `self.fill(**kwargs)`.  This is\noptimized to do as much work as possible up front and can be\nconsiderably faster if repeated often.\n\n#### Fragment.prepare(self) -> Tuple[str, Callable[..., List[Any]]]\n\nRenders `self` into a SQL query string; returns that string and a\nfunction that when called with `**kwargs` containing the unfilled\nslots of `self` will return a list containing the placeholder values\nfor `self` as filled with `**kwargs`.\n\n```python\n>>> query, query_args = sql("UPDATE tbl SET foo={foo}, bar={bar} WHERE baz < {baz}", baz=10).prepare()\n>>> query\n\'UPDATE tbl SET foo=$1, bar=$2 WHERE baz < $3\'\n>>> query_args(foo=1, bar=2)\n[1, 2, 10]\n>>> query_args(bar=42, foo=3)\n[3, 42, 10]\n```\n\nAs the name implies this is intended to be used in prepared\nstatements:\n\n```python\nquery, query_args = sql("UPDATE tbl SET foo={foo}, bar={bar} WHERE baz < {baz}", baz=10).prepare()\nstmt = await conn.prepare(query)\nawait stmt.execute(*query_args(foo=1, bar=2))\nawait stmt.execute(*query_args(bar=42, foo=3))\n```\n\n#### Fragment.sqlalchemy_text(self) -> sqlalchemy.sql.expression.TextClause\n\nRenders `self` into a SQLAlchemy `TextClause`.  Placeholder values\nwill be bound with `bindparams`.  Unfilled slots will be included as\nunbound parameters with their keys equal to the slot names.  A\nplaceholder value may be a SQLAlchemy `BindParameter`, in which case\nits value and type are used for the parameter created by this (and the\nkey name is ignored); this allow control of the SQLAlchemy type used\nfor the parameter.\n\nRequires SQLAlchemy to be installed, otherwise raises `ImportError`.\n\n```python\n>>> query = sql("SELECT * FROM tbl WHERE column = {}", 42)\n>>> stmt = query.sqlalchemy_text()\n>>> stmt._bindparams\n{\'_arg_0_140685932797232\': BindParameter(\'_arg_0_140685932797232\', 42, type_=Integer())}\n>>> conn.execute(stmt).fetchall()\n\n>>> query = sql("SELECT * FROM tbl WHERE column = {}", bindparam("ignored", 42, type_=Float()))\n>>> stmt = query.sqlalchemy_text()\n>>> stmt._bindparams\n{\'_arg_0_140294062155280\': BindParameter(\'_arg_0_140294062155280\', 42, type_=Float())}\n>>> conn.execute(stmt).fetchall()\n\n>>> query = sql("SELECT * FROM tbl WHERE column = {val}")\n>>> stmt = query.sqlalchemy_text()\n>>> stmt._bindparams\n{\'val\': BindParameter(\'val\', None, type_=NullType())}\n>>> conn.execute(stmt, val=42).fetchall()\n```\n\n## Dataclass helpers\n\n### Example\n\n```python\nfrom dataclasses import dataclass, field\nfrom datetime import date\nfrom uuid import UUID, uuid4\nfrom typing import Optional\n\nfrom sql_athame import ModelBase, model_field_metadata as MD, sql\n\n\n@dataclass\nclass Person(ModelBase, table_name="people", primary_key="id"):\n    id: UUID\n    name: str\n    birthday: date\n    title: Optional[str] = None\n    extra: Optional[dict] = field(default=None, metadata=MD(type="JSONB"))\n\n\n>>> list(Person.create_table_sql())\n[\'CREATE TABLE IF NOT EXISTS "people" (\'\n \'"id" UUID NOT NULL, \'\n \'"name" TEXT NOT NULL, \'\n \'"birthday" DATE NOT NULL, \'\n \'"title" TEXT, \'\n \'"extra" JSONB, \'\n \'PRIMARY KEY ("id"))\']\n\n>>> list(Person.select_sql(where=sql("title = {}", "Director")))\n[\'SELECT "id", "name", "birthday", "title", "extra" FROM "people" WHERE title = $1\',\n \'Director\']\n\n>>> people = [Person(uuid4(), "Bob", date(1974, 4, 3)), Person(uuid4(), "Anne", date(1985, 5, 4), extra={"awesome": "yes"})]\n>>> people\n[Person(id=UUID(\'8ecfe514-8fa3-48e5-8edb-fa810f5ed3f0\'), name=\'Bob\', birthday=datetime.date(1974, 4, 3), title=None, extra=None),\n Person(id=UUID(\'8d9bfadc-0026-4f6d-ae1b-ed89d1077f66\'), name=\'Anne\', birthday=datetime.date(1985, 5, 4), title=None, extra={\'awesome\': \'yes\'})]\n\n>>> list(Person.insert_multiple_sql(people))\n[\'INSERT INTO "people" ("id", "name", "birthday", "title", "extra")\'\n \' SELECT * FROM UNNEST($1::UUID[], $2::TEXT[], $3::DATE[], $4::TEXT[], $5::TEXT[]::JSONB[])\',\n (UUID(\'8ecfe514-8fa3-48e5-8edb-fa810f5ed3f0\'),\n  UUID(\'8d9bfadc-0026-4f6d-ae1b-ed89d1077f66\')),\n (\'Bob\', \'Anne\'),\n (datetime.date(1974, 4, 3), datetime.date(1985, 5, 4)),\n (None, None),\n [None, \'{"awesome": "yes"}\']]\n\n>>> list(Person.upsert_sql(Person.insert_multiple_sql(people)))\n[\'INSERT INTO "people" ("id", "name", "birthday", "title", "extra")\'\n \' SELECT * FROM UNNEST($1::UUID[], $2::TEXT[], $3::DATE[], $4::TEXT[], $5::TEXT[]::JSONB[])\'\n \' ON CONFLICT ("id") DO UPDATE\'\n \' SET "name"=EXCLUDED."name", "birthday"=EXCLUDED."birthday", "title"=EXCLUDED."title", "extra"=EXCLUDED."extra"\',\n (UUID(\'8ecfe514-8fa3-48e5-8edb-fa810f5ed3f0\'),\n  UUID(\'8d9bfadc-0026-4f6d-ae1b-ed89d1077f66\')),\n (\'Bob\', \'Anne\'),\n (datetime.date(1974, 4, 3), datetime.date(1985, 5, 4)),\n (None, None),\n [None, \'{"awesome": "yes"}\']]\n```\n\n### API reference\n\nTODO, for now read the [source](sql_athame/dataclasses.py).\n\n## License\n\nMIT.\n\n---\nCopyright (c) 2019, 2020 Brian Downing\n',
-    'author': 'Brian Downing',
-    'author_email': 'bdowning@lavos.net',
-    'maintainer': None,
-    'maintainer_email': None,
-    'url': 'https://github.com/bdowning/sql-athame',
-    'packages': packages,
-    'package_data': package_data,
-    'install_requires': install_requires,
-    'extras_require': extras_require,
-    'python_requires': '>=3.7,<4.0',
-}
-
-
-setup(**setup_kwargs)