fix: clamp count() at 0 when offset exceeds total (#2208)

* fix: clamp count() to limit/offset semantics at the edges

COUNT(*) ignores LIMIT/OFFSET, so CountQuery applies them in Python. Two edge
cases didn't match the limited query result:
- offset greater than the total returned a negative number (e.g.
  .offset(100).count() == -95 for 5 rows) instead of 0.
- limit(0) returned the full total instead of 0, because the limit clamp used
  a truthiness check (`if self._limit`) that skips 0.

Clamp the offset subtraction at 0 and use `self._limit is not None` so an
explicit limit(0) is honored.

* docs: reference count fix PR in changelog

* test: format count edge assertions

Author: koriyoshi2041

CHANGELOG.rst

@@ -21,6 +21,7 @@ Added
 Fixed
 ^^^^^
 - ``MigrationRecorder`` now uses parameterized queries; fixes MariaDB/MySQL rejecting ISO-8601 ``applied_at`` values. (#2132)
+- ``QuerySet.count()`` now matches the limited query result for the LIMIT/OFFSET edge cases: it returns ``0`` (instead of a negative number) when ``offset()`` exceeds the total row count, and ``0`` (instead of the total) for ``limit(0)``. (#2208)
 
 1.1.7
 -----

tests/test_queryset.py

@@ -88,6 +88,14 @@ async def test_limit_count(db, intfields_data):
     assert await IntFields.all().limit(10).count() == 10
 
 
+@pytest.mark.asyncio
+async def test_limit_zero_count(db, intfields_data):
+    # limit(0) means zero rows, so count() must be 0 (not the total), matching
+    # the actual limited query.
+    assert await IntFields.all().limit(0).count() == 0
+    assert await IntFields.all().limit(0).count() == len(await IntFields.all().limit(0))
+
+
 @pytest.mark.asyncio
 async def test_limit_negative(db, intfields_data):
     with pytest.raises(ParamsError, match="Limit should be non-negative number"):
@@ -106,6 +114,14 @@ async def test_offset_count(db, intfields_data):
     assert await IntFields.all().offset(10).count() == 20
 
 
+@pytest.mark.asyncio
+async def test_offset_count_beyond_total(db, intfields_data):
+    # An offset past the total must report 0, not a negative count (the SQL
+    # LIMIT/OFFSET would return zero rows).
+    assert await IntFields.all().offset(100).count() == 0
+    assert await IntFields.all().offset(100).count() == len(await IntFields.all().offset(100))
+
+
 @pytest.mark.asyncio
 async def test_offset_negative(db, intfields_data):
     with pytest.raises(ParamsError, match="Offset should be non-negative number"):

tortoise/queryset.py

@@ -1571,8 +1571,13 @@ async def _execute(self) -> int:
         _, result = await self._db.execute_query(*self.query.get_parameterized_sql())
         if not result:
             return 0
-        count = list(dict(result[0]).values())[0] - self._offset
-        if self._limit and count > self._limit:
+        # COUNT(*) ignores LIMIT/OFFSET, so the offset is applied here. Clamp at
+        # 0: when the offset is past the total, SQL would return 0 rows, not a
+        # negative count.
+        count = max(0, list(dict(result[0]).values())[0] - self._offset)
+        # Use ``is not None`` so an explicit ``limit(0)`` clamps to 0 instead of
+        # being treated as "no limit" by a truthiness check.
+        if self._limit is not None and count > self._limit:
             return self._limit
         return count