TypeDAL 3.8.5__tar.gz → 3.9.1__tar.gz

{typedal-3.8.5 → typedal-3.9.1}/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 <!--next-version-placeholder-->
 
+## v3.9.1 (2024-10-25)
+
+### Fix
+
+* Bool(QueryBuilder) should NOT look at the data but if any filters were applied ([`962ddf3`](https://github.com/trialandsuccess/TypeDAL/commit/962ddf37f5d1ac014b73fd6349099100cc7efb5f))
+
+## v3.9.0 (2024-10-25)
+
+### Feature
+
+* Add `condition_and` to .join so you can add additional requirements to inner joins ([`0ae688b`](https://github.com/trialandsuccess/TypeDAL/commit/0ae688ba01f421c70a660b5bb5d9672484494aa4))
+
 ## v3.8.5 (2024-10-24)
 
 ### Fix

{typedal-3.8.5 → typedal-3.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: TypeDAL
-Version: 3.8.5
+Version: 3.9.1
 Summary: Typing support for PyDAL
 Project-URL: Documentation, https://typedal.readthedocs.io/
 Project-URL: Issues, https://github.com/trialandsuccess/TypeDAL/issues

{typedal-3.8.5 → typedal-3.9.1}/src/typedal/__about__.py

@@ -5,4 +5,4 @@ This file contains the Version info for this package.
 # SPDX-FileCopyrightText: 2023-present Robin van der Noord <robinvandernoord@gmail.com>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "3.8.5"
+__version__ = "3.9.1"

{typedal-3.8.5 → typedal-3.9.1}/src/typedal/core.py

@@ -130,6 +130,7 @@ class Relationship(typing.Generic[To_Type]):
     _type: To_Type
     table: Type["TypedTable"] | type | str
     condition: Condition
+    condition_and: Condition
     on: OnQuery
     multiple: bool
     join: JOIN_OPTIONS
@@ -140,6 +141,7 @@ class Relationship(typing.Generic[To_Type]):
         condition: Condition = None,
         join: JOIN_OPTIONS = None,
         on: OnQuery = None,
+        condition_and: Condition = None,
     ):
         """
         Should not be called directly, use relationship() instead!
@@ -152,6 +154,7 @@ class Relationship(typing.Generic[To_Type]):
         self.condition = condition
         self.join = "left" if on else join  # .on is always left join!
         self.on = on
+        self.condition_and = condition_and
 
         if args := typing.get_args(_type):
             self.table = unwrap_type(args[0])
@@ -172,6 +175,7 @@ class Relationship(typing.Generic[To_Type]):
             update.get("condition") or self.condition,
             update.get("join") or self.join,
             update.get("on") or self.on,
+            update.get("condition_and") or self.condition_and,
         )
 
     def __repr__(self) -> str:
@@ -180,6 +184,10 @@ class Relationship(typing.Generic[To_Type]):
         """
         if callback := self.condition or self.on:
             src_code = inspect.getsource(callback).strip()
+
+            if c_and := self.condition_and:
+                and_code = inspect.getsource(c_and).strip()
+                src_code += " AND " + and_code
         else:
             cls_name = self._type if isinstance(self._type, str) else self._type.__name__  # type: ignore
             src_code = f"to {cls_name} (missing condition)"
@@ -1050,11 +1058,12 @@ class TableMeta(type):
         method: JOIN_OPTIONS = None,
         on: OnQuery | list[Expression] | Expression = None,
         condition: Condition = None,
+        condition_and: Condition = None,
     ) -> "QueryBuilder[T_MetaInstance]":
         """
         See QueryBuilder.join!
         """
-        return QueryBuilder(self).join(*fields, on=on, condition=condition, method=method)
+        return QueryBuilder(self).join(*fields, on=on, condition=condition, method=method, condition_and=condition_and)
 
     def collect(self: Type[T_MetaInstance], verbose: bool = False) -> "TypedRows[T_MetaInstance]":
         """
@@ -2221,9 +2230,19 @@ class QueryBuilder(typing.Generic[T_MetaInstance]):
 
     def __bool__(self) -> bool:
         """
-        Querybuilder is truthy if it has rows.
+        Querybuilder is truthy if it has any conditions.
         """
-        return self.count() > 0
+        table = self.model._ensure_table_defined()
+        default_query = typing.cast(Query, table.id > 0)
+        return any(
+            [
+                self.query != default_query,
+                self.select_args,
+                self.select_kwargs,
+                self.relationships,
+                self.metadata,
+            ]
+        )
 
     def _extend(
         self,
@@ -2317,6 +2336,7 @@ class QueryBuilder(typing.Generic[T_MetaInstance]):
         method: JOIN_OPTIONS = None,
         on: OnQuery | list[Expression] | Expression = None,
         condition: Condition = None,
+        condition_and: Condition = None,
     ) -> "QueryBuilder[T_MetaInstance]":
         """
         Include relationship fields in the result.
@@ -2326,8 +2346,13 @@ class QueryBuilder(typing.Generic[T_MetaInstance]):
 
         By default, the `method` defined in the relationship is used.
             This can be overwritten with the `method` keyword argument (left or inner)
+
+        `condition_and` can be used to add extra conditions to an inner join.
         """
         # todo: allow limiting amount of related rows returned for join?
+        # todo: it would be nice if 'fields' could be an actual relationship
+        #   (Article.tags = list[Tag]) and you could change the .condition and .on
+        #  this could deprecate condition_and
 
         relationships = self.model.get_relationships()
 
@@ -2340,7 +2365,9 @@ class QueryBuilder(typing.Generic[T_MetaInstance]):
             if isinstance(condition, pydal.objects.Query):
                 condition = as_lambda(condition)
 
-            relationships = {str(fields[0]): Relationship(fields[0], condition=condition, join=method)}
+            relationships = {
+                str(fields[0]): Relationship(fields[0], condition=condition, join=method, condition_and=condition_and)
+            }
         elif on:
             if len(fields) != 1:
                 raise ValueError("join(field, on=...) can only be used with exactly one field!")
@@ -2350,15 +2377,17 @@ class QueryBuilder(typing.Generic[T_MetaInstance]):
 
             if isinstance(on, list):
                 on = as_lambda(on)
-            relationships = {str(fields[0]): Relationship(fields[0], on=on, join=method)}
+            relationships = {str(fields[0]): Relationship(fields[0], on=on, join=method, condition_and=condition_and)}
 
         else:
             if fields:
                 # join on every relationship
-                relationships = {str(k): relationships[str(k)] for k in fields}
+                relationships = {str(k): relationships[str(k)].clone(condition_and=condition_and) for k in fields}
 
             if method:
-                relationships = {str(k): r.clone(join=method) for k, r in relationships.items()}
+                relationships = {
+                    str(k): r.clone(join=method, condition_and=condition_and) for k, r in relationships.items()
+                }
 
         return self._extend(relationships=relationships)
 
@@ -2579,7 +2608,6 @@ class QueryBuilder(typing.Generic[T_MetaInstance]):
 
         metadata["relationships"] = set(self.relationships.keys())
 
-        # query = self._update_query_for_inner(db, model, query)
         join = []
         for key, relation in self.relationships.items():
             if not relation.condition or relation.join != "inner":
@@ -2587,7 +2615,11 @@ class QueryBuilder(typing.Generic[T_MetaInstance]):
 
             other = relation.get_table(db)
             other = other.with_alias(f"{key}_{hash(relation)}")
-            join.append(other.on(relation.condition(model, other)))
+            condition = relation.condition(model, other)
+            if callable(relation.condition_and):
+                condition &= relation.condition_and(model, other)
+
+            join.append(other.on(condition))
 
         if limitby := select_kwargs.pop("limitby", ()):
 
@@ -2637,12 +2669,12 @@ class QueryBuilder(typing.Generic[T_MetaInstance]):
                 # .on not given, generate it:
                 other = other.with_alias(f"{key}_{hash(relation)}")
                 condition = typing.cast(Query, relation.condition(model, other))
+                if callable(relation.condition_and):
+                    condition &= relation.condition_and(model, other)
                 left.append(other.on(condition))
             else:
                 # else: inner join (handled earlier)
                 other = other.with_alias(f"{key}_{hash(relation)}")  # only for replace
-                # other = other.with_alias(f"{key}_{hash(relation)}")
-                # query &= relation.condition(model, other)
 
             # if no fields of 'other' are included, add other.ALL
             # else: only add other.id if missing

{typedal-3.8.5 → typedal-3.9.1}/tests/test_query_builder.py

@@ -400,8 +400,16 @@ def test_complex_join():
 
 
 def test_reprs_and_bool():
-    assert TestQueryTable.where(id=1)
-    assert not TestQueryTable.where(id=101)
+    _setup_data()
+
+    # NOTE: This logic changed: any 'empty' query table is False, and adding any conditions make it True.
+    empty = TestQueryTable.where()
+    notempty = TestQueryTable.where(id=1)
+    assert (empty or notempty) is notempty
+    assert (notempty or empty) is notempty
+    assert not empty
+    assert notempty
+    assert TestQueryTable.where(id=10000000000)
 
     assert repr(TestQueryTable.where(id=1))
     assert str(TestQueryTable.where(id=1))

{typedal-3.8.5 → typedal-3.9.1}/tests/test_relationships.py

@@ -295,6 +295,7 @@ def test_typedal_way():
 
 
 def test_reprs():
+    _setup_data()
     assert "Relationship:left on=" in repr(Article.tags)
 
     article = Article.first()
@@ -323,6 +324,16 @@ def test_reprs():
 
     assert empty.get_table_name() == "new"
 
+    relation = Article.join("author").relationships["author"]
+
+    assert "AND" not in repr(relation)
+
+    relation = Article.join("author",
+                            condition_and=lambda article, author: author.name != "Hank"
+                            ).relationships["author"]
+
+    assert "AND" in repr(relation) and "Hank" in repr(relation)
+
 
 @db.define()
 class CacheFirst(TypedTable):
@@ -355,6 +366,33 @@ def test_relationship_detection():
     assert user_table_relationships["extra_roles"].join == "left"
 
 
+def test_join_with_different_condition():
+    _setup_data()
+
+    role_with_users = Role.join(
+        "users",
+        method="inner",
+    ).first()
+
+    assert role_with_users.users
+    assert role_with_users.users[0].name == "Reader 1"
+
+    role_with_users = Role.join(
+        "users", method="inner", condition_and=lambda role, user: ~user.name.like("Reader%")
+    ).first()
+
+    assert role_with_users.users
+    assert role_with_users.users[0].name != "Reader 1"
+
+    # left:
+    role_with_users = Role.join(
+        "users", method="left", condition_and=lambda role, user: ~user.name.like("Reader%")
+    ).first()
+
+    assert role_with_users.users
+    assert role_with_users.users[0].name != "Reader 1"
+
+
 def test_caching():
     uncached = User.join().collect_or_fail()
     cached = User.cache().join().collect_or_fail()  # not actually cached yet!
@@ -538,11 +576,11 @@ def test_caching_dependencies():
 
 def test_illegal():
     with pytest.raises(ValueError), pytest.warns(UserWarning):
+
         class HasRelationship:
             something = relationship("...", condition=lambda: 1, on=lambda: 2)
 
 
-
 def test_join_with_select():
     _setup_data()