TypeDAL 4.9.3__tar.gz → 4.9.4__tar.gz

{typedal-4.9.3 → typedal-4.9.4}/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 <!--next-version-placeholder-->
 
+## v4.9.4 (2026-07-03)
+
+### Fix
+
+* **query_builder:** Include orderby fields in distinct-id subquery for paginated joins ([`d343a43`](https://github.com/trialandsuccess/TypeDAL/commit/d343a4326fdbf93fb5fd8b5db061ea5b3355e3de))
+
 ## v4.9.3 (2026-07-03)
 
 ### Fix

{typedal-4.9.3 → typedal-4.9.4}/PKG-INFO

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

{typedal-4.9.3 → typedal-4.9.4}/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__ = "4.9.3"
+__version__ = "4.9.4"

{typedal-4.9.3 → typedal-4.9.4}/src/typedal/query_builder.py

@@ -818,6 +818,46 @@ class QueryBuilder[T_MetaInstance: _TypedTable]:
 
         return joins
 
+    def _selectable_orderby_fields(self, orderby: OrderBy | t.Iterable[OrderBy] | None) -> list[OrderBy]:
+        """Extract field values from pydal orderby expressions."""
+        if not orderby:
+            return []
+
+        if isinstance(orderby, (list, tuple, set)):
+            return [field for item in orderby for field in self._selectable_orderby_fields(item)]
+
+        if isinstance(orderby, pydal.objects.Field):
+            return [orderby]
+
+        fields = []
+        first = getattr(orderby, "first", None)
+        second = getattr(orderby, "second", None)
+
+        if first is not None:
+            fields.extend(self._selectable_orderby_fields(first))
+        if second is not None:
+            fields.extend(self._selectable_orderby_fields(second))
+
+        return fields
+
+    def _select_distinct_ids_with_orderby_fields(self, query: Query, select_kwargs: SelectKwargs) -> str:
+        db = self._get_db()
+        model = self.model
+        select_args: list[OrderBy] = [model.id]
+        seen = {str(model.id)}
+
+        for field in self._selectable_orderby_fields(select_kwargs.get("orderby")):
+            key = str(field)
+            if key not in seen:
+                select_args.append(field)
+                seen.add(key)
+
+        ids = db(query)._select(*select_args, **select_kwargs).rstrip(";")
+        id_column = getattr(model.id, "_raw_rname", model.id.name)
+        return f'SELECT "{id_column}" FROM ({ids}) AS typedal_paginate_ids'  # nosec:
+        # id_column originates from code
+        # ids is a safe subquery, originating from code
+
     def _apply_limitby_optimization(
         self,
         query: Query,
@@ -839,7 +879,11 @@ class QueryBuilder[T_MetaInstance: _TypedTable]:
             kwargs["join"] = joins
             kwargs["distinct"] = True
 
-        ids = db(query)._select(model.id, **kwargs)
+        if joins and kwargs.get("orderby"):
+            ids = self._select_distinct_ids_with_orderby_fields(query, kwargs)
+        else:
+            ids = db(query)._select(model.id, **kwargs)
+
         query = model.id.belongs(ids)
         metadata["ids"] = ids
 

{typedal-4.9.3 → typedal-4.9.4}/tests/test_query_builder.py

@@ -519,6 +519,10 @@ def test_orderby():
     base_qt = TestQueryTable.select(TestQueryTable.id, TestQueryTable.number)
 
     assert base_qt.count() == 5
+    assert base_qt._selectable_orderby_fields(None) == []
+
+    composite_fields = base_qt._selectable_orderby_fields(TestQueryTable.number | TestQueryTable.other)
+    assert composite_fields == [TestQueryTable.number, TestQueryTable.other]
 
     rows1 = base_qt.orderby(TestQueryTable.id).paginate(limit=3, page=1)
     rows2 = base_qt.select(orderby=TestQueryTable.id, limitby=(0, 3)).collect()
@@ -602,6 +606,45 @@ def test_select_kwargs_use_rname_psql(dal_psql: TypeDAL):
         assert "some_table.some_name" in sql
 
 
+def test_paginate_inner_joins_with_related_orderby_psql(dal_psql: TypeDAL):
+    db = dal_psql
+
+    @db.define()
+    class Method(TypedTable):
+        gid = TypedField(str)
+        name = TypedField(str)
+
+    @db.define()
+    class Supplier(TypedTable):
+        gid = TypedField(str)
+        name = TypedField(str)
+
+    @db.define()
+    class Product(TypedTable):
+        name = TypedField(str)
+        method: Method
+        supplier: Supplier
+
+    supplier = Supplier.insert(gid="supplier", name="Supplier")
+    slow = Method.insert(gid="slow", name="Slow")
+    fast = Method.insert(gid="fast", name="Fast")
+    Product.insert(name="Product slow", method=slow, supplier=supplier)
+    Product.insert(name="Product fast", method=fast, supplier=supplier)
+    db.commit()
+
+    builder = Product.join("method", method="inner").join("supplier", method="inner")
+    method_relation = builder.relationships["method"]
+    method_alias = method_relation.get_table(db).with_alias(f"method_{hash(method_relation)}")
+    builder = builder.orderby(method_alias.name)
+    builder = builder.select(Method.gid, Method.name)
+    builder = builder.select(Supplier.gid, Supplier.name)
+
+    page = builder.paginate(page=1, limit=1)
+
+    assert len(page) == 1
+    assert page.first().method.name == "Fast"
+
+
 def test_execute():
     _setup_data()