sqlalchemy-boltons 1.0.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

sqlalchemy_boltons/orm.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from sqlalchemy.sql import coercions as _coercions, util as _util
+
+
+class RelationshipComparator:
+    """
+    This wrapper makes it possible to compare a table against a relationship using :func:`join_expr`. This can be used
+    for constructing a subquery that filters using a relationship to a table from the outer query.
+
+    For example::
+
+        import sqlalchemy as sa
+        from sqlalchemy import orm as sao
+        from sqlalchemy_boltons.orm import RelationshipComparator as Rel
+
+        Base = sao.declarative_base()
+
+
+        class Parent(Base):
+            __tablename__ = "parent"
+
+            id = sa.Column(sa.Integer, primary_key=True)
+
+            children = sao.relationship("Child", back_populates="parent")
+
+
+        class Child(Base):
+            __tablename__ = "child"
+
+            id = sa.Column(sa.Integer, primary_key=True)
+            parent_id = sa.Column(sa.ForeignKey("parent.id"), index=True)
+
+            parent = sao.relationship("Parent", back_populates="children")
+
+
+        # We want a query that selects every Parent that has at least one child. We also want to use aliases.
+        P = sao.aliased(Parent)
+        C = sao.aliased(Child)
+
+        # This is the boring old way of doing it, which requires explicitly stating the filtering conditions in terms
+        # of the columns in both tables.
+        q1 = sa.select(P).where(sa.select(C).where(C.parent_id == P.id).exists())
+
+        # Reuse the filtering conditions from the ORM relationship!
+        q2 = sa.select(P).where(sa.select(C).where(Rel(C.parent) == P).exists())
+
+        assert str(q1) == str(q2), "these should produce the same SQL code!"
+
+    Based on this discussion: https://groups.google.com/g/sqlalchemy/c/R-qOlzzVi0o/m/NtFswgJioDIJ
+    """
+
+    def __init__(self, relationship):
+        self._relationship = relationship
+
+    def __eq__(self, other):
+        if other is None:
+            raise TypeError("cannot compare against None")
+        return join_expr(other, self._relationship)
+
+    def __ne__(self, other):
+        return ~(self == other)
+
+
+def join_expr(right, relationship):
+    """
+    Turn an ORM relationship into an expression that you can use for filtering.
+    """
+
+    expr = _coercions.expect(_coercions.roles.ColumnArgumentRole, relationship)
+    if right is not None:
+        right = _coercions.expect(_coercions.roles.FromClauseRole, right)
+        expr = _util.ClauseAdapter(right).traverse(expr)
+    return expr

sqlalchemy_boltons/sqlite.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import dataclasses as dc
 import functools
 from pathlib import Path
@@ -54,6 +56,16 @@ class SQLAlchemySqliteTransactionFix:
     This class exists because sqlalchemy doesn't automatically fix pysqlite's stupid default behaviour. Additionally,
     we implement support for foreign keys.
 
+    The execution options we look for are as follows:
+
+    - `x_sqlite_begin_mode`: The type of transaction to be started, such as "BEGIN" or
+      "[BEGIN IMMEDIATE](https://www.sqlite.org/lang_transaction.html)" (or
+      "[BEGIN CONCURRENT](https://www.sqlite.org/cgi/src/doc/begin-concurrent/doc/begin_concurrent.md)" someday maybe).
+    - `x_sqlite_foreign_keys`: The [foreign-key enforcement setting](https://www.sqlite.org/foreignkeys.html). Must be
+      `True`, `False`, or `"defer"`.
+    - `x_sqlite_journal_mode`: The [journal mode](https://www.sqlite.org/pragma.html#pragma_journal_mode) such as
+      `"DELETE"` or `"WAL"`. Optional.
+
     https://docs.sqlalchemy.org/en/20/dialects/sqlite.html#serializable-isolation-savepoints-transactional-ddl
     """
 
@@ -188,6 +200,9 @@ def create_engine_sqlite(
     # always default to QueuePool
     if (k := "poolclass") not in create_engine_args:
         create_engine_args[k] = sap.QueuePool
+        if (k := "max_overflow") not in create_engine_args:
+            # for SQLite it doesn't make sense to restrict the number of concurrent (read-only) connections
+            create_engine_args["max_overflow"] = -1
 
     if (v := create_engine_args.get(k := "connect_args")) is None:
         create_engine_args[k] = v = {}

{sqlalchemy_boltons-1.0.1.dist-info → sqlalchemy_boltons-2.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sqlalchemy-boltons
-Version: 1.0.1
+Version: 2.0.0
 Summary: Utilities that should've been inside SQLAlchemy but aren't
 Author-email: Eduard Christian Dumitrescu <eduard.c.dumitrescu@gmail.com>
 Maintainer-email: Eduard Christian Dumitrescu <eduard.c.dumitrescu@gmail.com>
@@ -71,3 +71,36 @@ with Session() as session:
 with SessionW() as session:
     session.execute(update(...))
 ```
+
+## orm
+
+Somedays you really wish you could write something like:
+
+```python
+# Find every parent that has at least one child.
+Parent1 = aliased(Parent)
+select(Parent1).where(
+    exists().select_from(Child).where(Child.parent == Parent1)  # this doesn't work
+)
+```
+
+But it doesn't work. You get an exception. You try various other things but it just won't produce the right subquery.
+You find tons of people online saying you must resign yourself to writing the explicit filtering condition, writing out
+`.where(Child.parent_id == Parent1.id)`. Like a caveman. Why even bother using an ORM at this point? If you're lucky,
+you find yourself reading mail archives from [a decade ago](https://groups.google.com/g/sqlalchemy/c/R-qOlzzVi0o/m/NtFswgJioDIJ)
+with somewhat of a solution, but it's not obvious how to make it work with table
+[aliases](https://docs.sqlalchemy.org/en/20/orm/queryguide/api.html#sqlalchemy.orm.aliased). Despair is setting in.
+
+But lucky you, you can now use this library:
+
+```python
+from sqlalchemy_boltons.orm import RelationshipComparator as Rel
+
+# Find every parent that has at least one child.
+Parent1 = aliased(Parent)
+select(Parent1).where(
+    exists().select_from(Child).where(Rel(Child.parent) == Parent1)
+)  #                                  ^^^^            ^
+```
+
+Hope is restored.

sqlalchemy_boltons-2.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+sqlalchemy_boltons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlalchemy_boltons/orm.py,sha256=vCRQX1NjpJh-b_PEgEDT4Mk1cgy3JRRNjq0AnszJWbA,2489
+sqlalchemy_boltons/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlalchemy_boltons/sqlite.py,sha256=r875URPWSrHxIBR5lfTK82us0yP5i32GgtW2R_DXhoY,8889
+sqlalchemy_boltons-2.0.0.dist-info/AUTHORS.md,sha256=sXkm88GaYJ63k0Hy7UlGboAT4aytU8e1_K0wNo7WwD8,144
+sqlalchemy_boltons-2.0.0.dist-info/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlalchemy_boltons-2.0.0.dist-info/METADATA,sha256=PA9TEywSFVYd8x3Pb0_RBesQbO-zaMA0_GeHTL5rG1U,4168
+sqlalchemy_boltons-2.0.0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+sqlalchemy_boltons-2.0.0.dist-info/top_level.txt,sha256=mlvZ3R5FelrQt2SNXCtw2bDXcTROxl5O_gDFnWXPQ84,19
+sqlalchemy_boltons-2.0.0.dist-info/RECORD,,

sqlalchemy_boltons-1.0.1.dist-info/RECORD

@@ -1,9 +0,0 @@
-sqlalchemy_boltons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlalchemy_boltons/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlalchemy_boltons/sqlite.py,sha256=fIS9rsmEFRakSl8DLwHqVJ-M9K1w6Q0XEJieYNH1b98,7985
-sqlalchemy_boltons-1.0.1.dist-info/AUTHORS.md,sha256=sXkm88GaYJ63k0Hy7UlGboAT4aytU8e1_K0wNo7WwD8,144
-sqlalchemy_boltons-1.0.1.dist-info/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sqlalchemy_boltons-1.0.1.dist-info/METADATA,sha256=t5yyOnZzl415Jo4q4gh2YeJD-EtDYdLEdqT0qolPzn4,2852
-sqlalchemy_boltons-1.0.1.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-sqlalchemy_boltons-1.0.1.dist-info/top_level.txt,sha256=mlvZ3R5FelrQt2SNXCtw2bDXcTROxl5O_gDFnWXPQ84,19
-sqlalchemy_boltons-1.0.1.dist-info/RECORD,,