surreal-orm-lite 0.32.0__tar.gz → 0.32.1__tar.gz

{surreal_orm_lite-0.32.0 → surreal_orm_lite-0.32.1}/CHANGELOG.md

@@ -5,6 +5,50 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.32.1] - 2026-10-20
+
+Two follow-ups to the materialized views of v0.32.0 (#286): a function SurrealDB lists as unusable
+in a view is allowed inside the argument of each of several aggregates, and a chain of views can
+be removed outer view first in one buffered transaction. No new public API.
+
+### Fixed
+
+- **A listed function inside the argument of each of several aggregates passes the
+  `view_query` check** (#286). Since v0.32.0, a grouped view whose projection calls
+  `array::distinct()`, `array::group()`, `array::join()`, `math::median()` or `vector::sum()`
+  outside an aggregate's argument raises `ValueError` at the `class` statement, but only an element
+  that is one whole aggregate had its calls skipped: an expression combining several aggregates,
+  such as `math::sum(amount) + math::sum(array::len(array::distinct(tags)))`, was refused on every
+  line. Such an expression now passes the check; a listed function beside or around an aggregate
+  (`math::sum(amount) + array::len(array::distinct(tags))`) is still refused, with the same
+  message. SurrealDB 3.x keeps such a view up to date; on 2.x and the embedded engine
+  `define_view()` still refuses an expression around aggregates before any DDL, as in v0.32.0.
+  `generate_models_from_db()` follows the check: such a view table is now generated as a view
+  model instead of a class carrying a `# View: AS …` comment.
+- **`remove_view()` accepts a chain of views removed outer view first in one buffered
+  transaction** (#286). On SurrealDB 2.x and the embedded engine, `remove_view()` refuses with
+  `SurrealDbError`, before any DDL, to remove a view that another view reads, and it read committed
+  state only, so this block was refused although the server accepts both statements at commit:
+
+  ```python
+  async with SurrealDBConnectionManager.transaction() as tx:
+      await OrderStatsTotals.remove_view(tx=tx)  # the outer view, queued
+      await OrderStats.remove_view(tx=tx)        # refused: the outer view was still counted
+  ```
+
+  In a buffered transaction (SurrealDB 2.x, HTTP, the embedded engine), a view whose
+  `remove_view(tx=tx)` the same block has already queued is no longer counted, unless the block
+  names it again afterwards (a `define_view(tx=tx)` of it). A view removed in another transaction,
+  or by a `REMOVE TABLE` you add to the block yourself (`tx.add(…)`), is still counted: the check
+  errs on the side of the refusal. SurrealDB 3.x decides by itself, as before.
+
+### Notes
+
+- README section 33 and the "ORM behaviour: SurrealDB 2.x vs 3.x" row on removing a view that
+  another view reads say so.
+- Server pins unchanged: tested against SurrealDB 3.3.4 and 2.7.0 and on the embedded engine,
+  plus 3.1.5 for backward compatibility.
+
 ## [0.32.0] - 2026-10-20
 
 Materialized views as read-only models: a model declares the `SELECT` that SurrealDB computes a

{surreal_orm_lite-0.32.0 → surreal_orm_lite-0.32.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: surreal-orm-lite
-Version: 0.32.0
+Version: 0.32.1
 Summary: Lightweight Django-style ORM for SurrealDB using the official Python SDK. Async support with Pydantic validation.
 Project-URL: Homepage, https://github.com/EulogySnowfall/SurrealDB-ORM-lite
 Project-URL: Documentation, https://github.com/EulogySnowfall/SurrealDB-ORM-lite
@@ -4848,9 +4848,11 @@ print([(str(order.id), order.amount) for order in await PaidOrder.objects().orde
   date: `count()`, `math::sum()`, `math::mean()`, `math::min()`, `math::max()`, `time::min()`, `time::max()` (and
   `math::stddev()`, `math::variance()` on 3.x), whatever their argument (`math::sum(amount ?? 0)`). `math::median()`,
   `array::group()`, `array::distinct()`, `array::join()` and `vector::sum()` are refused (inside an aggregate's
-  argument they are allowed). On SurrealDB 3.x an expression around an aggregate (`math::sum(amount) / count()`) and
-  a `GROUP BY` on an alias work; on 2.x and the embedded engine `define_view()` refuses them (see "SurrealDB 2.x and
-  3.x" below).
+  argument they are allowed). Since v0.32.1 that holds when an expression combines several aggregates too
+  (`math::sum(amount) + math::sum(array::len(array::distinct(tags)))`); beside an aggregate
+  (`math::sum(amount) + array::len(array::distinct(tags))`) they are still refused. On SurrealDB 3.x an expression
+  around an aggregate (`math::sum(amount) / count()`) and a `GROUP BY` on an alias work; on 2.x and the embedded
+  engine `define_view()` refuses them (see "SurrealDB 2.x and 3.x" below).
 - Every source write runs the view's query for that record: when it fails — a function given a value of the wrong
   type, an aggregated field missing
   ([surrealdb/surrealdb#7447](https://github.com/surrealdb/surrealdb/issues/7447)) — SurrealDB refuses the write, on
@@ -4928,6 +4930,10 @@ print([(str(order.id), order.amount) for order in await PaidOrder.objects().orde
   (`objects(tx=tx)`), unseen outside the block until it commits. Either way, a block that raises leaves no view. The
   table guard and the 2.x checks run before anything is queued, on committed state; a refusal of a queued statement
   comes back when the block commits, as the transaction's own error.
+- A chain of views can be removed in one buffered block, outer view first (since v0.32.1): on 2.x and the embedded
+  engine `remove_view(tx=tx)` does not count a view whose `remove_view(tx=tx)` the same block has already queued,
+  unless the block names it again afterwards (a `define_view(tx=tx)` of it). A view removed in another transaction,
+  or by a `REMOVE TABLE` you add to the block yourself, is still counted.
 - Both run on the model's connection (its `connection` key, or the `using()` block's); a `tx=` of another connection
   raises `SurrealDbError` before any request. A view and its source tables live in one database: give a view model
   its sources' connection.
@@ -5253,7 +5259,7 @@ The SDK's in-process engine has a table of its own: [ORM behaviour: the embedded
 | A grouped view whose `GROUP BY` names the alias of a computed field (`time::month(at) AS month` … `GROUP BY month`)                    | `SurrealDbError` before any DDL: the server would put every source record in one group                                                                                        | one group per computed value                                                                                                                                                        | v0.32.0                              |
 | Values a view computes (`math::sum()`, `math::mean()`, `count()` of an array)                                                          | a sum of integers is an `int`, a mean a `Decimal`; `count(tags)` of an array field adds the arrays' lengths                                                                   | both are `float`; `count(tags)` counts the records whose array is not empty                                                                                                         | v0.32.0                              |
 | Live queries and events on a view (a group emptied by a delete; a live query filtered on `id`)                                         | an emptied group: an `UPDATE` with the emptied values (a `count()` of 0), then a `DELETE`; a filter on `id` notifies                                                          | an emptied group: a `DELETE`; a filter on `id` never notifies (the view's notifications carry no `id`): filter on the view's fields                                                 | v0.32.0                              |
-| Removing a materialized view, or a source table, that another view reads (`remove_view()`, `REMOVE TABLE`)                             | `remove_view()` raises `SurrealDbError` before any DDL; a raw `REMOVE TABLE` succeeds and turns each view reading the table into an ordinary table keeping its last records   | `SurrealDbError` from the server (`Cannot delete table … on which a view is defined`): remove the views that read it first                                                          | v0.32.0                              |
+| Removing a materialized view, or a source table, that another view reads (`remove_view()`, `REMOVE TABLE`)                             | `remove_view()` raises `SurrealDbError` before any DDL, unless its transaction removes those views first; a raw `REMOVE TABLE` makes them ordinary tables, last records kept  | `SurrealDbError` from the server (`Cannot delete table … on which a view is defined`): remove the views that read it first                                                          | v0.32.0                              |
 | Full suite and every divergence in this table, re-run on SurrealDB 2.7.0 and 3.3.0                                                     | 2.7.0 identical to 2.6.5 (same passes, same 3.x-only skips)                                                                                                                   | 3.3.0 identical to 3.2.4, except the system-user signin row                                                                                                                         | v0.19.1                              |
 
 > **Note on record IDs**: A record loaded from the database has its `id` field set to a native `surrealdb.RecordID` object, not a plain string. Use `model.get_raw_id()` to obtain the bare identifier string (e.g. `"alice"`), or compare directly with `model.id == RecordID("User", "alice")`. In-memory instances you construct yourself retain whatever value you assign.

{surreal_orm_lite-0.32.0 → surreal_orm_lite-0.32.1}/README.md

@@ -4797,9 +4797,11 @@ print([(str(order.id), order.amount) for order in await PaidOrder.objects().orde
   date: `count()`, `math::sum()`, `math::mean()`, `math::min()`, `math::max()`, `time::min()`, `time::max()` (and
   `math::stddev()`, `math::variance()` on 3.x), whatever their argument (`math::sum(amount ?? 0)`). `math::median()`,
   `array::group()`, `array::distinct()`, `array::join()` and `vector::sum()` are refused (inside an aggregate's
-  argument they are allowed). On SurrealDB 3.x an expression around an aggregate (`math::sum(amount) / count()`) and
-  a `GROUP BY` on an alias work; on 2.x and the embedded engine `define_view()` refuses them (see "SurrealDB 2.x and
-  3.x" below).
+  argument they are allowed). Since v0.32.1 that holds when an expression combines several aggregates too
+  (`math::sum(amount) + math::sum(array::len(array::distinct(tags)))`); beside an aggregate
+  (`math::sum(amount) + array::len(array::distinct(tags))`) they are still refused. On SurrealDB 3.x an expression
+  around an aggregate (`math::sum(amount) / count()`) and a `GROUP BY` on an alias work; on 2.x and the embedded
+  engine `define_view()` refuses them (see "SurrealDB 2.x and 3.x" below).
 - Every source write runs the view's query for that record: when it fails — a function given a value of the wrong
   type, an aggregated field missing
   ([surrealdb/surrealdb#7447](https://github.com/surrealdb/surrealdb/issues/7447)) — SurrealDB refuses the write, on
@@ -4877,6 +4879,10 @@ print([(str(order.id), order.amount) for order in await PaidOrder.objects().orde
   (`objects(tx=tx)`), unseen outside the block until it commits. Either way, a block that raises leaves no view. The
   table guard and the 2.x checks run before anything is queued, on committed state; a refusal of a queued statement
   comes back when the block commits, as the transaction's own error.
+- A chain of views can be removed in one buffered block, outer view first (since v0.32.1): on 2.x and the embedded
+  engine `remove_view(tx=tx)` does not count a view whose `remove_view(tx=tx)` the same block has already queued,
+  unless the block names it again afterwards (a `define_view(tx=tx)` of it). A view removed in another transaction,
+  or by a `REMOVE TABLE` you add to the block yourself, is still counted.
 - Both run on the model's connection (its `connection` key, or the `using()` block's); a `tx=` of another connection
   raises `SurrealDbError` before any request. A view and its source tables live in one database: give a view model
   its sources' connection.
@@ -5202,7 +5208,7 @@ The SDK's in-process engine has a table of its own: [ORM behaviour: the embedded
 | A grouped view whose `GROUP BY` names the alias of a computed field (`time::month(at) AS month` … `GROUP BY month`)                    | `SurrealDbError` before any DDL: the server would put every source record in one group                                                                                        | one group per computed value                                                                                                                                                        | v0.32.0                              |
 | Values a view computes (`math::sum()`, `math::mean()`, `count()` of an array)                                                          | a sum of integers is an `int`, a mean a `Decimal`; `count(tags)` of an array field adds the arrays' lengths                                                                   | both are `float`; `count(tags)` counts the records whose array is not empty                                                                                                         | v0.32.0                              |
 | Live queries and events on a view (a group emptied by a delete; a live query filtered on `id`)                                         | an emptied group: an `UPDATE` with the emptied values (a `count()` of 0), then a `DELETE`; a filter on `id` notifies                                                          | an emptied group: a `DELETE`; a filter on `id` never notifies (the view's notifications carry no `id`): filter on the view's fields                                                 | v0.32.0                              |
-| Removing a materialized view, or a source table, that another view reads (`remove_view()`, `REMOVE TABLE`)                             | `remove_view()` raises `SurrealDbError` before any DDL; a raw `REMOVE TABLE` succeeds and turns each view reading the table into an ordinary table keeping its last records   | `SurrealDbError` from the server (`Cannot delete table … on which a view is defined`): remove the views that read it first                                                          | v0.32.0                              |
+| Removing a materialized view, or a source table, that another view reads (`remove_view()`, `REMOVE TABLE`)                             | `remove_view()` raises `SurrealDbError` before any DDL, unless its transaction removes those views first; a raw `REMOVE TABLE` makes them ordinary tables, last records kept  | `SurrealDbError` from the server (`Cannot delete table … on which a view is defined`): remove the views that read it first                                                          | v0.32.0                              |
 | Full suite and every divergence in this table, re-run on SurrealDB 2.7.0 and 3.3.0                                                     | 2.7.0 identical to 2.6.5 (same passes, same 3.x-only skips)                                                                                                                   | 3.3.0 identical to 3.2.4, except the system-user signin row                                                                                                                         | v0.19.1                              |
 
 > **Note on record IDs**: A record loaded from the database has its `id` field set to a native `surrealdb.RecordID` object, not a plain string. Use `model.get_raw_id()` to obtain the bare identifier string (e.g. `"alice"`), or compare directly with `model.id == RecordID("User", "alice")`. In-memory instances you construct yourself retain whatever value you assign.

{surreal_orm_lite-0.32.0 → surreal_orm_lite-0.32.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "surreal-orm-lite"
-version = "0.32.0"
+version = "0.32.1"
 description = "Lightweight Django-style ORM for SurrealDB using the official Python SDK. Async support with Pydantic validation."
 readme = "README.md"
 requires-python = ">=3.11"

{surreal_orm_lite-0.32.0 → surreal_orm_lite-0.32.1}/src/surreal_orm_lite/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.32.0"
+__version__ = "0.32.1"
 
 from ._sdk import BoundExcluded, BoundIncluded
 from .aggregations import Aggregation, Avg, Count, Max, Min, Sum

{surreal_orm_lite-0.32.0 → surreal_orm_lite-0.32.1}/src/surreal_orm_lite/model_base.py

@@ -30,6 +30,7 @@ from .schema import (
     check_view_config,
     check_view_query,
     dependent_views,
+    dependents_not_removed,
     ensure_async_events_supported,
     ensure_view_query_supported,
     ensure_view_removable,
@@ -54,7 +55,7 @@ from .signals import (
     pre_save,
     pre_update,
 )
-from .transaction import Transaction
+from .transaction import BufferedTransaction, Transaction
 from .types import Duration, _duration_from_sdk, _timedelta_from_sdk
 from .utils import (
     PLAIN_CONTENT,
@@ -1145,6 +1146,13 @@ class BaseSurrealModel(BaseModel):
         their queries only (a view reading the table through a graph path or a sub-select is left to the server), and
         the line is read from ``client.version()`` only when one is found.
 
+        A chain of views can be removed in one buffered transaction (SurrealDB 2.x, HTTP, the embedded engine), outer
+        view first (v0.32.1): a view whose removal the same *tx* has already queued with ``remove_view()`` — the last
+        statement of the block naming it — is not counted, though the committed ``INFO FOR DB`` still lists it. It is
+        counted again when the block names it after that removal (a ``define_view()`` of it), when it is removed in
+        another transaction or by a ``tx.add("REMOVE TABLE …")`` written by hand. On SurrealDB 3.x the server decides,
+        as before.
+
         Args:
             missing_ok: ``True`` (default) emits ``REMOVE TABLE IF EXISTS …``, so a missing view is not an error;
                 ``False`` raises ``SurrealDbNotFoundError`` for it.
@@ -1178,9 +1186,11 @@ class BaseSurrealModel(BaseModel):
         if existing == "unreadable":
             raise SurrealDbError(view_table_refused("G3", cls.__name__, table, removal=True))
         if existing == "view":
-            await ensure_view_removable(
-                client, table, dependent_views(tables, table), model=cls.__name__, embedded=manager.is_embedded()
-            )
+            dependents = dependent_views(tables, table)
+            if isinstance(tx, BufferedTransaction):
+                # Issue #286: the views this block has already queued for removal are gone when it commits.
+                dependents = dependents_not_removed(dependents, tx.statements)
+            await ensure_view_removable(client, table, dependents, model=cls.__name__, embedded=manager.is_embedded())
         await apply_ddl_statements(
             [statement],
             client=client,

{surreal_orm_lite-0.32.0 → surreal_orm_lite-0.32.1}/src/surreal_orm_lite/schema.py

@@ -37,8 +37,9 @@ the DDL, not a lock. Before the guard, ``define_view()`` refuses on SurrealDB 2.
 projection those engines compute once per source record (``ensure_view_query_supported()``, C1), reading the line
 from ``client.version()`` only when the query holds one; 3.x keeps such a view up to date or refuses it itself. On the
 guard's one ``INFO FOR DB``, ``remove_view()`` finds the views that read the view it removes (``dependent_views()``,
-through the plain ``FROM`` targets ``view_reads_table()`` reads) and, when there is one, refuses on SurrealDB 2.x and
-the embedded engine before any DDL (``ensure_view_removable()``, G5): those engines would remove it and turn those
+through the plain ``FROM`` targets ``view_reads_table()`` reads; in a buffered transaction, without those whose
+removal the block has already queued, ``dependents_not_removed()``) and, when there is one, refuses on SurrealDB 2.x
+and the embedded engine before any DDL (``ensure_view_removable()``, G5): those engines would remove it and turn those
 views into ordinary tables that no longer update, where 3.x refuses the removal itself.
 
 The module sits low in the package: it imports neither ``model_base`` nor ``connection_manager``, so both can import
@@ -556,16 +557,21 @@ class ViewElement:
       (``math::sum(amount)``), else ``None``.
     - ``calls``: the lower-cased names of the functions it calls (a ``::`` path, or ``count``), in order, nested calls
       included.
+    - ``free_calls``: the calls of ``calls`` that stand outside the argument of every call of an aggregate SurrealDB
+      keeps up to date (``count``, ``math::sum`` … ``math::variance``), in order — the aggregate calls themselves
+      included, the calls inside their arguments left out (v0.32.1, issue #286): ``("math::sum", "math::sum")`` for
+      ``math::sum(a) + math::sum(array::len(array::distinct(tags)))``.
     - ``fields``: the fields it reads, in order, a repeated one repeated (``("*",)`` for ``*``); ``()`` when
       ``aggregate`` is set — the aggregate's argument is read per record, as SurrealDB intends.
-    - ``opaque``: it holds a sub-select or a graph path, which the reading does not analyse (``calls`` and ``fields``
-      are then empty).
+    - ``opaque``: it holds a sub-select or a graph path, which the reading does not analyse (``calls``,
+      ``free_calls`` and ``fields`` are then empty).
     """
 
     text: str
     alias: str | None
     aggregate: str | None
     calls: tuple[str, ...]
+    free_calls: tuple[str, ...]
     fields: tuple[str, ...]
     opaque: bool
 
@@ -613,8 +619,12 @@ def check_view_query(value: object, *, model: str) -> str:
     - V6: it is a ``SELECT VALUE``: a view stores records;
     - V7: it groups its records (a top-level ``GROUP BY`` or ``GROUP ALL``) and its projection calls one of
       ``array::distinct``, ``array::group``, ``array::join``, ``math::median``, ``vector::sum`` (in any case) outside
-      an element that is one whole aggregate call: SurrealDB documents them as unusable in a view. Inside an
-      aggregate's argument (``math::max(array::len(array::distinct(tags)))``) they work on every line.
+      the argument of every aggregate call (``ViewElement.free_calls``): SurrealDB documents them as unusable in a
+      view. Inside an aggregate's argument (``math::max(array::len(array::distinct(tags)))``) they work on every line,
+      also when an element combines several aggregates (``math::sum(amount) +
+      math::sum(array::len(array::distinct(tags)))``, since v0.32.1): such an expression around aggregates passes V7,
+      and ``define_view()`` refuses it on SurrealDB 2.x and the embedded engine (C1). Beside or around an aggregate
+      (``math::sum(a) + array::len(array::distinct(tags))``) they are still refused.
 
     The check catches mistakes — unbalanced brackets, a comment that would swallow the parenthesis the ORM appends, a
     second statement where one SELECT is expected — and is not an injection defence: a view's query is trusted
@@ -643,13 +653,7 @@ def check_view_query(value: object, *, model: str) -> str:
     outline = view_query_outline(text)
     if outline.grouped:
         unusable = next(
-            (
-                call
-                for element in outline.elements
-                if element.aggregate is None
-                for call in element.calls
-                if call in _NOT_VIEW_AGGREGATES
-            ),
+            (call for element in outline.elements for call in element.free_calls if call in _NOT_VIEW_AGGREGATES),
             None,
         )
         if unusable is not None:
@@ -760,6 +764,29 @@ def _view_fields(blanked: str) -> tuple[str, ...]:
     return tuple(name for name in _VIEW_FIELD.findall(plain) if name.upper() not in _PROJECTION_KEYWORDS)
 
 
+def _view_calls(blanked: str) -> tuple[tuple[str, ...], tuple[str, ...]]:
+    """``(calls, free_calls)`` of the blanked expression *blanked*, as :class:`ViewElement` describes them.
+
+    Each call is read in order; one that starts inside the argument of an aggregate call read before it (up to that
+    call's closing bracket, found on the blanked text, so a bracket inside a literal is never one) is a call, not a free
+    call (issue #286)."""
+    calls: list[str] = []
+    free_calls: list[str] = []
+    argument_end = -1
+    for match in _VIEW_CALL.finditer(blanked):
+        name = match.group(1).lower()
+        if "::" not in name and name != "count":
+            continue
+        calls.append(name)
+        if match.start() < argument_end:
+            continue
+        free_calls.append(name)
+        if name in _ALL_VIEW_AGGREGATES:
+            closing = _closing_bracket(blanked, match.end() - 1)
+            argument_end = len(blanked) if closing is None else closing
+    return tuple(calls), tuple(free_calls)
+
+
 def _view_element(text: str, blanked: str, top: str) -> ViewElement:
     """One projection element from its three slices (*text*, *blanked*, *top*, of the same length)."""
     alias: str | None = None
@@ -774,8 +801,8 @@ def _view_element(text: str, blanked: str, top: str) -> ViewElement:
     written = expression[left:right]
     plain = blanked[left:right] if right > left else ""
     if _VIEW_OPAQUE.search(plain) is not None:
-        return ViewElement(written, alias, None, (), (), True)
-    calls = tuple(name.lower() for name in _VIEW_CALL.findall(plain) if "::" in name or name.lower() == "count")
+        return ViewElement(written, alias, None, (), (), (), True)
+    calls, free_calls = _view_calls(plain)
     aggregate: str | None = None
     first = _VIEW_CALL.match(plain)
     if (
@@ -785,7 +812,7 @@ def _view_element(text: str, blanked: str, top: str) -> ViewElement:
     ):
         aggregate = first.group(1).lower()
     fields = () if aggregate is not None else _view_fields(plain)
-    return ViewElement(written, alias, aggregate, calls, fields, False)
+    return ViewElement(written, alias, aggregate, calls, free_calls, fields, False)
 
 
 def view_query_outline(text: str) -> ViewOutline:
@@ -795,9 +822,9 @@ def view_query_outline(text: str) -> ViewOutline:
     the server. Literals are blanked first (``define_parser.blank_literals()``), so a keyword, a call or a comma inside
     a string or a quoted name is never read. ``grouped`` is a top-level ``GROUP BY``/``GROUP ALL``; the projection
     runs from ``SELECT`` to the top-level ``FROM`` (or the end) and is split at its top-level commas; each element's
-    alias, calls, whole aggregate and fields are read as :class:`ViewElement` describes. A sub-select or a graph path
-    (``->``, ``<-``) makes the element opaque, and a backquoted or ``⟨⟩`` field name is invisible: both are left to
-    the server. Pure.
+    alias, calls, free calls, whole aggregate and fields are read as :class:`ViewElement` describes. A sub-select or a
+    graph path (``->``, ``<-``) makes the element opaque, and a backquoted or ``⟨⟩`` field name is invisible: both are
+    left to the server. Pure.
     """
     blanked, top = _top_level(text)
     grouping = _VIEW_GROUP.search(top)
@@ -1116,6 +1143,33 @@ def dependent_views(tables: Mapping[str, Any], table: str) -> tuple[str, ...]:
     return tuple(sorted(names))
 
 
+def dependents_not_removed(dependents: Sequence[str], statements: Sequence[str]) -> tuple[str, ...]:
+    """The views of *dependents* that the *statements* queued in a buffered transaction do not remove, in order
+    (v0.32.1, issue #286).
+
+    G5 (:func:`ensure_view_removable`) reads committed state, where a view whose removal the same buffered block has
+    already queued is still listed: removing a chain of views outer view first in one block would be refused. A
+    dependent is left out when the last of *statements* that names it — as a whole name, in any case, quoted or not —
+    is exactly the removal ``remove_view()`` queues for it (:func:`remove_view_statement`, with ``missing_ok`` ``True``
+    or ``False``). It is kept when no statement names it, when a statement names it after its removal (a
+    ``DEFINE TABLE … AS`` that defines it again, or any other), when its removal was written by hand
+    (``tx.add("REMOVE TABLE …")``), and when its name is not an identifier: a reading of the text, not a parser, that
+    errs on the side of the refusal. Pure.
+    """
+    left: list[str] = []
+    for name in dependents:
+        try:
+            removals = {remove_view_statement(name, True), remove_view_statement(name, False)}
+        except (TypeError, ValueError):
+            left.append(name)
+            continue
+        naming = re.compile(rf"(?<!\w){re.escape(name)}(?!\w)", re.IGNORECASE)
+        last = next((statement for statement in reversed(statements) if naming.search(statement)), None)
+        if last not in removals:
+            left.append(name)
+    return tuple(left)
+
+
 async def ensure_view_removable(client: Any, table: str, dependents: Sequence[str], *, model: str, embedded: bool) -> None:
     """Refuse, on a connection before SurrealDB 3.x, to remove the view *table* that other views read — before any
     DDL (G5, v0.32.0).
@@ -1123,7 +1177,9 @@ async def ensure_view_removable(client: Any, table: str, dependents: Sequence[st
     While a view reads a table — a source table or an inner view —, SurrealDB 3.x refuses to remove it (``Cannot
     delete table … on which a view is defined``). SurrealDB 2.x and the embedded engine remove it, and every view that
     read it loses its ``AS`` clause: an ordinary table that keeps its last records and no longer updates. *dependents*
-    are those views (:func:`dependent_views`, over the table guard's one ``INFO FOR DB``): none, and nothing is read.
+    are those views (:func:`dependent_views`, over the table guard's one ``INFO FOR DB``; in a buffered transaction,
+    without those whose removal the block has already queued, :func:`dependents_not_removed`): none, and nothing is
+    read.
     Else the line is read from ``client.version()`` with the lite's rule (``time_travel.line_major()``): on 3.x — or a
     version that cannot be read — the removal goes on and the server refuses it; before 3.x, G5 names the dependent
     views, sorted. On the embedded engine ``version()`` answers the SDK's version (``surrealdb-2.0.0``), whose bundled