django-data-shape 0.17.0__tar.gz → 0.18.0__tar.gz

{django_data_shape-0.17.0 → django_data_shape-0.18.0}/CHANGELOG.md

@@ -7,6 +7,64 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.18.0] — 2026-09-05
+
+### Added
+
+- **`Projection(..., max_rows=N)`: a declared ceiling, checked before the insert.**
+
+  A projection is the one declaration with no `rows=`, deliberately -- its
+  cardinality comes from the join, which is what reproduces a correlation a
+  `FanOut` on the child would destroy. The consequence is that the largest table
+  in a database can be the one nobody declared a size for, and it grows as a
+  **product**: when both sides of the join fan out over the same parents, the
+  busy parents multiply, so raising either declared count by four grows the
+  result by sixteen. A consumer measured 2,413,223 rows against a declaration
+  whose largest number was 300,000.
+
+  The count is taken first and compared, so a declaration that has run away
+  costs a scan of the join rather than the time to write every row of it. It is
+  exact rather than estimated: the derived form counts the same join the insert
+  selects from, and a `sql=` projection is counted by wrapping the caller's own
+  select, because this package cannot know what that statement is one row per.
+
+  The refusal names the number it would have written and the tables the join is
+  over, because the surprise is never the ceiling -- a reader told only that a
+  limit was exceeded still has to work out which of the two counts moved.
+
+  **A declaration that does not ask is not charged for the answer**: with no
+  ceiling, no count is taken. There is no default ceiling and there will not be
+  one -- how many rows is too many is a judgement about size, which this package
+  does not make on a caller's behalf anywhere else either.
+
+
+## [0.17.1] — 2026-09-05
+
+### Fixed
+
+- **A scaled world left the identity sequence pointing at rows that came back**,
+  a regression introduced by 0.17.0 and found by the consumer that prompted it.
+
+  0.17.0 made `scaled_world` empty the tables its shape declares, so a session
+  world could sit under one, and the rows come back because the emptying happens
+  inside the transaction it rolls back. The **sequence** does not: `setval` is
+  not transactional, so the counter kept whatever the scaled build moved it to.
+  A scaled world is usually *smaller* than the session world it was built over,
+  which left the counter below the ids that had just returned.
+
+  The symptom was an `IntegrityError` on a primary key, in a later test, for a
+  row the failing test never wrote.
+
+  The sequences are now recomputed once the transaction has ended -- from
+  `max(pk)` of whatever actually survived, rather than from a number captured on
+  the way in, so it is correct in both directions and correct too when the
+  caller's block raised partway through the build.
+
+  The Postgres statement-count constant moved from 17 to 19: one reset per
+  declared table, a property of the declaration rather than the factor, so what
+  those tests pin is unchanged. The portable constant did not move, because
+  Django emits no sequence reset for a SQLite table without `AUTOINCREMENT`.
+
 ## [0.17.0] — 2026-09-05
 
 ### Added
@@ -1115,7 +1173,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   into `COPY FROM STDIN`, which psycopg 2 cannot do without materialising them
   first.
 
-[Unreleased]: https://github.com/Artui/django-data-shape/compare/v0.17.0...HEAD
+[Unreleased]: https://github.com/Artui/django-data-shape/compare/v0.18.0...HEAD
+[0.18.0]: https://github.com/Artui/django-data-shape/compare/v0.17.1...v0.18.0
+[0.17.1]: https://github.com/Artui/django-data-shape/compare/v0.17.0...v0.17.1
 [0.17.0]: https://github.com/Artui/django-data-shape/compare/v0.16.0...v0.17.0
 [0.16.0]: https://github.com/Artui/django-data-shape/compare/v0.15.0...v0.16.0
 [0.15.0]: https://github.com/Artui/django-data-shape/compare/v0.14.0...v0.15.0

{django_data_shape-0.17.0 → django_data_shape-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: django-data-shape
-Version: 0.17.0
+Version: 0.18.0
 Summary: A realistically shaped test database from Django models: declare cardinality, skew and fan-out, load by COPY, and make the query planner believe it.
 Project-URL: Homepage, https://github.com/Artui/django-data-shape
 Project-URL: Repository, https://github.com/Artui/django-data-shape

{django_data_shape-0.17.0 → django_data_shape-0.18.0}/django_data_shape/build.py

@@ -8,7 +8,6 @@ from functools import partial
 from itertools import islice
 from typing import Any, cast
 
-from django.core.management.color import no_style
 from django.db import DEFAULT_DB_ALIAS, connections, transaction
 from django.db.models import Model
 
@@ -32,6 +31,7 @@ from django_data_shape.shape import Shape
 from django_data_shape.shape_not_empty import ShapeNotEmpty
 from django_data_shape.table import Table
 from django_data_shape.table_result import TableResult
+from django_data_shape.utils import reset_sequence
 
 # Big enough that the per-statement overhead disappears and small enough that
 # the peak list is a rounding error next to the rows themselves.
@@ -120,7 +120,7 @@ def build(
             else:
                 plans, pairings = _resolve(connection, table, shape.seed)
                 loaded = _load(connection, table, shape.seed, plans, pairings)
-            _reset_sequence(connection, table.model)
+            reset_sequence(connection, table.model)
             _analyze(connection, table.db_table)
             results.append(TableResult(table=table.db_table, rows=loaded))
         # The second of the three nets, and the only one that covers a rule the
@@ -133,6 +133,44 @@ def build(
     return BuildResult(tables=tuple(results))
 
 
+def _require_within_ceiling(connection: Any, projection: Projection) -> None:
+    """Refuse a projection that has outgrown its declared ceiling, before it runs.
+
+    Before rather than after, which is the whole value: the count costs a
+    scan of the join and the insert costs writing every row of it, so a
+    declaration that has run away is stopped for the price of the cheaper half.
+    A ceiling that is not declared costs nothing at all -- no count is taken.
+
+    The message names the number it would have written and the tables the join
+    is over, because the surprise here is never the ceiling. A projection's size
+    is a *product*: when both sides fan out over the same parents, the busy
+    parents multiply, and raising either declared count by four grows the result
+    by sixteen. A reader who is told only that a limit was exceeded has to go
+    and work out which of the two counts moved.
+    """
+    ceiling = projection.max_rows
+    if ceiling is None:
+        return
+    statement, params = projection.count_statement(connection)
+    with connection.cursor() as cursor:
+        cursor.execute(statement, params)
+        row = cursor.fetchone()
+    would_insert = int(row[0])
+    if would_insert <= ceiling:
+        return
+    over = ", ".join(model.__name__ for model in projection.reads)
+    raise InvalidShape(
+        f"The projection into {projection.db_table} would insert {would_insert:,} rows, "
+        f"which is over its declared max_rows={ceiling:,}. Nothing was written. "
+        f"A projection has no row count of its own: its size is one row per pair along "
+        f"the join it copies, over {over or 'the tables its statement selects from'}. "
+        "That size is a product, so when both sides of the join fan out over the same "
+        "parents the busy parents multiply and raising either declared count by four "
+        "grows this by sixteen. Either the ceiling is too low, or one of those counts "
+        "moved further than it looked."
+    )
+
+
 def _project(connection: Any, projection: Projection, seed: int) -> int:
     """Fill a table from tables already built, with one ``INSERT ... SELECT``.
 
@@ -148,6 +186,7 @@ def _project(connection: Any, projection: Projection, seed: int) -> int:
     one of the few that cannot happen at declaration time, because what it
     depends on lives in the other tables rather than in the declaration.
     """
+    _require_within_ceiling(connection, projection)
     statement, params = projection.statement(connection, seed)
     with connection.cursor() as cursor:
         cursor.execute(statement, params)
@@ -380,20 +419,6 @@ def _insert(
     return loaded
 
 
-def _reset_sequence(connection: Any, model: type[Model]) -> None:
-    """Move the identity sequence past the keys this package just assigned.
-
-    Skipping this is the first bug the design invites: rows exist at ids 1..N
-    while the sequence still starts at 1, so the very first ``objects.create()``
-    inside a test raises ``IntegrityError`` on a primary key that is already
-    taken. Django's own backend operation is used rather than a hand-written
-    ``setval`` because it already knows how the column's sequence is named.
-    """
-    with connection.cursor() as cursor:
-        for statement in connection.ops.sequence_reset_sql(no_style(), [model]):
-            cursor.execute(statement)
-
-
 def _analyze(connection: Any, db_table: str) -> None:
     """Populate the statistics the planner reads.
 

{django_data_shape-0.17.0 → django_data_shape-0.18.0}/django_data_shape/projection.py

@@ -177,6 +177,7 @@ class Projection:
         reads: Sequence[type[Model]] = (),
         keys: KeyStrategy | None = None,
         statistics: Mapping[str, int] | None = None,
+        max_rows: int | None = None,
     ) -> None:
         self._model = model
         self._per = per
@@ -186,6 +187,16 @@ class Projection:
         self._params = tuple(params)
         self._reads: tuple[type[Model], ...] = tuple(reads)
         self._statistics = dict(statistics or {})
+        # A bool is an int as far as isinstance is concerned, and a ceiling of
+        # one row is never what ``max_rows=True`` meant. Refused here rather
+        # than compared later, where it would silently be a very low ceiling.
+        if max_rows is not None and (isinstance(max_rows, bool) or max_rows < 1):
+            raise InvalidShape(
+                f"{model.__name__} declares max_rows={max_rows!r}. A ceiling is a whole "
+                "number of rows and at least one, because a projection that inserts "
+                "nothing is already refused."
+            )
+        self._max_rows = max_rows
         self._copied: tuple[tuple[str, str, str], ...] = ()
         self._literals: tuple[tuple[str, object], ...] = ()
         self._columns: tuple[str, ...] = ()
@@ -246,6 +257,31 @@ class Projection:
             return self._reads
         return (cast("type[Model]", self._per), cast("type[Model]", self._copying))
 
+    @property
+    def max_rows(self) -> int | None:
+        """The largest number of rows this declaration is willing to insert.
+
+        ``None``, and no count is taken -- a declaration that does not ask is
+        not charged for the answer.
+
+        It exists because a projection is the one declaration with no ``rows=``,
+        and that is deliberate: its cardinality comes from the join, which is
+        what reproduces a correlation a ``FanOut`` on the child would destroy.
+        The consequence is that the largest table in a database can be the one
+        nobody declared a size for. **Its size is a product**, so when both
+        sides of the join fan out over the same parents the busy parents
+        multiply: raise either declared count by four and the projection grows
+        by sixteen. A consumer measured 2,413,223 rows against a declaration
+        whose largest number was 300,000.
+
+        There is no default ceiling and there will not be one. How many rows is
+        too many is a judgement about size, which this package does not make on
+        a caller's behalf anywhere else either -- see the statistics target,
+        declared for the same reason. What it can do is act on the caller's own
+        number, before the expensive statement rather than after it.
+        """
+        return self._max_rows
+
     def statement(self, connection: Any, seed: int) -> tuple[str, tuple[object, ...]]:
         """The ``INSERT ... SELECT`` this declaration means, and its parameters.
 
@@ -266,6 +302,32 @@ class Projection:
         defaults = tuple(value for _column, value in self._literals)
         return f"{into} {self._select(quote, seed)}", defaults
 
+    def count_statement(self, connection: Any) -> tuple[str, tuple[object, ...]]:
+        """How many rows the insert would write, without writing them.
+
+        Exact rather than estimated: it counts the same join the insert selects
+        from, and the select is one row per joined pair, so the two agree by
+        construction. The derived form counts the join directly rather than
+        wrapping the select -- the window function and the ordering decide what
+        the rows *are* and cost real time, while the question here is only how
+        many. A ``sql=`` projection is wrapped instead, because this package
+        cannot know what the caller's statement is one row per.
+        """
+        quote = connection.ops.quote_name
+        if self._sql is not None:
+            return f"SELECT count(*) FROM ({self._sql}) AS {quote('counted')}", self._params
+        per = cast("type[Model]", self._per)
+        source = cast("type[Model]", self._copying)
+        per_alias, source_alias = quote(_PER), quote(_SOURCE)
+        per_link, source_link = self._join
+        return (
+            f"SELECT count(*) "
+            f"FROM {quote(per._meta.db_table)} AS {per_alias} "
+            f"INNER JOIN {quote(source._meta.db_table)} AS {source_alias} "
+            f"ON {source_alias}.{quote(source_link)} = {per_alias}.{quote(per_link)}",
+            (),
+        )
+
     def _select(self, quote: Any, seed: int) -> str:
         """The derived select: the key, the copied columns, then the join."""
         per = cast("type[Model]", self._per)

{django_data_shape-0.17.0 → django_data_shape-0.18.0}/django_data_shape/scaled_world.py

@@ -11,6 +11,7 @@ from django_data_shape.build import build
 from django_data_shape.keys.disjoint import Disjoint
 from django_data_shape.scaled_shape import scaled_shape
 from django_data_shape.shape import Shape
+from django_data_shape.utils import reset_sequence
 
 
 @contextmanager
@@ -83,16 +84,32 @@ def scaled_world(shape: Shape, factor: int, *, using: str = DEFAULT_DB_ALIAS) ->
     after a world is torn down gets a larger id than it otherwise would.
     """
     scaled = scaled_shape(shape, factor)
-    with transaction.atomic(using=using):
-        _empty_declared_tables(scaled, using)
-        result = build(scaled, using=using, require_statistics=False)
-        yield result.rows
-        # Rolling back on the way out rather than raising and swallowing an
-        # exception to get there: set_rollback is the supported way to leave an
-        # atomic block without keeping it. An exception from the caller's block
-        # never reaches this line and does not need to -- atomic rolls back for
-        # exactly that case already.
-        transaction.set_rollback(True, using=using)
+    try:
+        with transaction.atomic(using=using):
+            _empty_declared_tables(scaled, using)
+            result = build(scaled, using=using, require_statistics=False)
+            yield result.rows
+            # Rolling back on the way out rather than raising and swallowing
+            # an exception to get there: set_rollback is the supported way to
+            # leave an atomic block without keeping it. An exception from the
+            # caller's block never reaches this line and does not need to --
+            # atomic rolls back for exactly that case already.
+            transaction.set_rollback(True, using=using)
+    finally:
+        # After the rollback, never inside it. The rows are back and the
+        # sequences are not: ``setval`` is not transactional, so the counter
+        # still holds whatever the scaled build moved it to -- and a scaled
+        # world is usually *smaller* than a session world built over, which
+        # leaves it pointing at ids that have just come back. The next
+        # ``objects.create()`` then collides with a row the failing test never
+        # wrote, in a later test, which is about as far from the cause as a
+        # symptom gets.
+        #
+        # Recomputed from the rows rather than restored from a number captured
+        # on the way in, because the reset reads ``max(pk)`` of whatever is
+        # actually there: it is then correct in both directions, and correct
+        # too when the caller's block raised partway through the build.
+        _reset_declared_sequences(scaled, using)
 
 
 def _empty_declared_tables(shape: Shape, using: str) -> None:
@@ -144,3 +161,16 @@ def _empty_declared_tables(shape: Shape, using: str) -> None:
             # does not matter.
             for name in reversed(tables):
                 cursor.execute(f"DELETE FROM {connection.ops.quote_name(name)}")
+
+
+def _reset_declared_sequences(shape: Shape, using: str) -> None:
+    """Point every declared table's sequence at the rows it now holds.
+
+    A :class:`~django_data_shape.projection.Projection` is included: its rows
+    come from a statement rather than from generated keys, but it still has a
+    key column with a sequence behind it, and the rows it just lost were as real
+    as any other's.
+    """
+    connection = connections[using]
+    for table in shape.tables:
+        reset_sequence(connection, table.model)

{django_data_shape-0.17.0 → django_data_shape-0.18.0}/django_data_shape/utils.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import hashlib
 from typing import Any
 
+from django.core.management.color import no_style
 from django.db.models import (
     DateField,
     DateTimeField,
@@ -232,3 +233,27 @@ def offsettable_kind(field: Field[Any, Any]) -> str | None:
     if isinstance(field, (IntegerField, FloatField, DecimalField)):
         return "number"
     return None
+
+
+def reset_sequence(connection: Any, model: type[Model]) -> None:
+    """Point the identity sequence at the rows the table currently holds.
+
+    Skipping it after a load is the first bug the design invites: rows exist at
+    ids 1..N while the sequence still starts at 1, so the very first
+    ``objects.create()`` inside a test raises ``IntegrityError`` on a primary key
+    that is already taken. Django's own backend operation is used rather than a
+    hand-written ``setval`` because it already knows how the column's sequence
+    is named.
+
+    **It is computed from the rows, not from a remembered number**, which is
+    what makes it correct to run again after a rollback as well as after a load.
+    ``setval`` is not transactional, so a scaled world built over a session
+    world leaves the counter at the scaled world's size while the session
+    world's larger rows come back underneath it -- and the next ``create()``
+    then collides with a row the failing test never wrote. Re-running this once
+    the transaction has ended reads whatever survived and agrees with it, in
+    either direction and with no state carried across the block.
+    """
+    with connection.cursor() as cursor:
+        for statement in connection.ops.sequence_reset_sql(no_style(), [model]):
+            cursor.execute(statement)

{django_data_shape-0.17.0 → django_data_shape-0.18.0}/django_data_shape/version.py

@@ -2,6 +2,6 @@
 
 from __future__ import annotations
 
-__version__: str = "0.17.0"
+__version__: str = "0.18.0"
 
 __all__ = ["__version__"]

{django_data_shape-0.17.0 → django_data_shape-0.18.0}/docs/projections.md

@@ -73,6 +73,55 @@ print(sessions.rows)
 It also means a projection needs no scale factor of its own. `scaled_shape`
 passes it through untouched, and it grows because the tables it reads did.
 
+### It grows as a product, which is the part that surprises
+
+A projection is one row per *pair* along the join, so its size is the inner
+product of the two sides. When both of them fan out over the same parents, the
+busy parents multiply:
+
+```python
+Table(Venue, rows=40, name=Constant("alhambra"))
+Table(VenueSeat, rows=24_000, venue=FanOut(Zipf(1.1)), number=Sequential(1, 1))
+Table(Show, rows=4_000, venue=FanOut(Zipf(1.15)), title=Constant("an evening with"))
+Projection(ShowSeat, per=Show, copying=VenueSeat)
+```
+
+```
+boxoffice_order      300,000     <- the largest number in the declaration
+boxoffice_showseat 2,413,223     <- eight times bigger, declared nowhere
+```
+
+Raise either declared count by four and the projection grows by **sixteen**.
+That is the model working as intended -- it is what reproduces a correlation a
+`FanOut` on the child would destroy -- but it does mean the largest table in a
+database can be the one nobody wrote a number for.
+
+### `max_rows` bounds it, before the insert rather than after
+
+```python
+Projection(ShowSeat, per=Show, copying=VenueSeat, max_rows=3_000_000)
+```
+
+The count is taken first and compared, so a declaration that has run away costs
+a scan of the join rather than the time to write every row of it. The refusal
+names the number it would have written and the tables the join is over, because
+the surprise is never the ceiling:
+
+```
+The projection into boxoffice_showseat would insert 12,058,114 rows, which is
+over its declared max_rows=3,000,000. Nothing was written. A projection has no
+row count of its own: its size is one row per pair along the join it copies,
+over Show, VenueSeat. That size is a product, so when both sides of the join fan
+out over the same parents the busy parents multiply and raising either declared
+count by four grows this by sixteen. Either the ceiling is too low, or one of
+those counts moved further than it looked.
+```
+
+A declaration that does not set one is not charged for the answer -- no count is
+taken. **There is no default ceiling and there will not be one**: how many rows
+is too many is a judgement about size, which this package does not make on your
+behalf anywhere else either. What it can do is act on your number, early.
+
 ## What gets derived
 
 **The join.** `per` and `copying` are joined through a model they both reach in

{django_data_shape-0.17.0 → django_data_shape-0.18.0}/pyproject.toml

@@ -170,7 +170,7 @@ skip-magic-trailing-comma = false
 root = ["./django_data_shape"]
 
 [tool.bumpversion]
-current_version = "0.17.0"
+current_version = "0.18.0"
 allow_dirty = false
 commit = false
 tag = false

django_data_shape-0.18.0/tests/test_projection_ceiling.py

@@ -0,0 +1,149 @@
+"""A projection's size is a product, and `max_rows` is how a declaration bounds it.
+
+`Projection` has no `rows=` on purpose: its cardinality comes from the join,
+which is what reproduces a correlation a `FanOut` on the child would destroy.
+The consequence is that the largest table in a database can be the one nobody
+declared a size for -- a consumer measured 2,413,223 rows against a declaration
+whose largest number was 300,000, because both sides of the join fan out over
+the same parents and the busy parents multiply.
+
+`max_rows` is checked *before* the insert, so a declaration that has run away
+costs a count rather than the ten minutes of writing the rows.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from django_data_shape import (
+    Constant,
+    FanOut,
+    InvalidShape,
+    Projection,
+    Sequential,
+    Shape,
+    Skew,
+    Table,
+    Uniform,
+    Zipf,
+    build,
+)
+from tests.testapp.models import Event, EventSession, Template, TemplateSession
+
+pytestmark = pytest.mark.django_db
+
+
+def _shape(*, max_rows: int | None) -> Shape:
+    return Shape(
+        Projection(EventSession, per=Event, copying=TemplateSession, max_rows=max_rows),
+        Table(Template, rows=4, name=Constant("t")),
+        Table(
+            TemplateSession,
+            rows=40,
+            template=FanOut(Zipf(1.1)),
+            title=Skew({"morning": 0.5, "evening": 0.5}),
+            minutes=Sequential(15, 1),
+        ),
+        Table(Event, rows=20, template=FanOut(Uniform(1, 4)), name=Constant("e")),
+        seed=3,
+    )
+
+
+def test_a_projection_under_its_ceiling_builds() -> None:
+    result = build(_shape(max_rows=100_000), require_statistics=False)
+
+    projected = next(table for table in result.tables if table.table == "testapp_eventsession")
+    assert projected.rows > 0
+
+
+def test_a_projection_over_its_ceiling_is_refused_before_it_inserts() -> None:
+    with pytest.raises(InvalidShape) as excinfo:
+        build(_shape(max_rows=3), require_statistics=False)
+
+    message = str(excinfo.value)
+    assert "testapp_eventsession" in message
+    assert "max_rows=3" in message
+    # The count it would have written, so the reader can decide whether the
+    # ceiling is wrong or the declaration is.
+    assert "would insert" in message
+
+    # Nothing was written: the refusal is the point, and a half-filled table
+    # would be worse than the runaway it prevents.
+    assert EventSession.objects.count() == 0
+
+
+def test_the_refusal_names_what_drives_the_size() -> None:
+    """The number surprises because it is a product, so the message says so."""
+    with pytest.raises(InvalidShape, match="Event"):
+        build(_shape(max_rows=3), require_statistics=False)
+
+
+def test_no_ceiling_costs_no_query() -> None:
+    """A declaration that does not ask is not charged for the answer."""
+    from django.db import connection
+    from django.test.utils import CaptureQueriesContext
+
+    with CaptureQueriesContext(connection) as without:
+        build(_shape(max_rows=None), require_statistics=False)
+
+    counted = [q for q in without.captured_queries if "count(" in q["sql"].lower()]
+    assert counted == []
+
+
+@pytest.mark.parametrize("bad", [0, -1, -100])
+def test_a_ceiling_below_one_is_refused_at_declaration(bad: int) -> None:
+    with pytest.raises(InvalidShape, match="max_rows"):
+        Projection(EventSession, per=Event, copying=TemplateSession, max_rows=bad)
+
+
+def test_a_ceiling_that_is_not_a_whole_number_is_refused() -> None:
+    """`True` is an int as far as isinstance is concerned, and a ceiling of one
+    row is never what a caller meant by it."""
+    with pytest.raises(InvalidShape, match="max_rows"):
+        Projection(EventSession, per=Event, copying=TemplateSession, max_rows=True)
+
+
+def _raw(*, max_rows: int) -> Shape:
+    """The escape hatch, whose count has to wrap rather than count a join.
+
+    This package cannot know what a caller's statement is one row per, so the
+    only honest count is the caller's own select with `count(*)` around it.
+    """
+    return Shape(
+        Table(Template, rows=4, name=Constant("t")),
+        Table(
+            TemplateSession,
+            rows=40,
+            template=FanOut(Zipf(1.1)),
+            title=Skew({"morning": 0.5, "evening": 0.5}),
+            minutes=Sequential(15, 1),
+        ),
+        Table(Event, rows=20, template=FanOut(Uniform(1, 4)), name=Constant("e")),
+        Projection(
+            EventSession,
+            columns=("id", "event", "title", "minutes", "channel"),
+            sql=(
+                "SELECT row_number() OVER (ORDER BY e.id, t.id), e.id, t.title, %s, %s "
+                f"FROM {Event._meta.db_table} e "
+                f"JOIN {TemplateSession._meta.db_table} t "
+                "ON t.template_id = e.template_id"
+            ),
+            params=(99, "import"),
+            reads=(Event, TemplateSession),
+            max_rows=max_rows,
+        ),
+        seed=3,
+    )
+
+
+def test_a_raw_projection_is_counted_by_wrapping_the_callers_select() -> None:
+    with pytest.raises(InvalidShape, match="max_rows=3"):
+        build(_raw(max_rows=3), require_statistics=False)
+
+    assert EventSession.objects.count() == 0
+
+
+def test_a_raw_projection_under_its_ceiling_builds() -> None:
+    build(_raw(max_rows=100_000), require_statistics=False)
+
+    assert EventSession.objects.count() > 0

{django_data_shape-0.17.0 → django_data_shape-0.18.0}/tests/test_scaled_world.py

@@ -168,7 +168,13 @@ def test_it_also_undoes_a_world_it_opened_the_transaction_for() -> None:
 # and stays a constant. Off PostgreSQL it is one DELETE per declared table --
 # two here -- which is a property of the *declaration* and not of the factor, so
 # the curve below still has the loader's own shape and only its intercept moved.
-_POSTGRES_STATEMENTS = 17
+#
+# And once more for the sequence reset that runs *after* the rollback, which is
+# one statement per declared table -- two here, again a property of the
+# declaration rather than the factor. PostgreSQL only: Django emits no sequence
+# reset for a SQLite table without AUTOINCREMENT, which is why the portable
+# constant did not move with it.
+_POSTGRES_STATEMENTS = 19
 _PORTABLE_STATEMENTS = 12
 _ROWS_PER_INSERT = 1000
 
@@ -189,8 +195,8 @@ def test_building_a_world_costs_the_same_on_postgres_at_every_factor() -> None:
     # The half that makes a capture around the block merely wrong rather than
     # catastrophic: COPY is not a wrapped statement, so the overhead is the
     # TRUNCATE, the emptiness check, the statistics-target read, the parent key
-    # read, the sequence reset, the ANALYZE and the savepoints -- none of which
-    # depend on how many rows there are.
+    # read, the two sequence resets, the ANALYZE and the savepoints -- none of
+    # which depend on how many rows there are.
     shape = _graph(companies=10, sessions=_ROWS_PER_INSERT)
 
     assert _statements(shape, 1, DEFAULT_DB_ALIAS) == _POSTGRES_STATEMENTS