Different fixes for issues that came out of a review

  1. None==None view corruption — fast-path guard now explicitly checks _tbl.base is None to exclude view-backed columns, preventing the guard from firing when _last_pos and _n_rows are
  both None on a view.
  2. CTable.__setitem__ missing view guard — added self.base is not None and self._read_only checks, matching the pattern of every other mutating CTable method.
  3. Fast path dead for disk-opened tables — replaced the raw _last_pos read with _tbl._resolve_last_pos(), which lazily computes and caches the value on first call. Also replaced
  len(self) (O(n) scan) with _tbl._n_rows (cached integer).
  4. Validation decompression — added a comment documenting that validate=True (the default) transiently decompresses NDArray inputs during constraint checking; validate=False is needed
  for fully bounded peak memory.

Author: FrancescAlted

src/blosc2/ctable.py

@@ -1050,14 +1050,20 @@ def __setitem__(self, key: int | slice | list | np.ndarray, value):  # noqa: C90
             # Fast path: slice of a blosc2.NDArray into a scalar or ndarray column when
             # there are no deleted rows (physical positions == logical positions).
             # Skips the O(n) validity-mask gather and decompresses one chunk at a time.
+            # Guards: must not be a view (views have _last_pos=_n_rows=None, so
+            # None==None would be True and bypass the physical-position remapping);
+            # _resolve_last_pos() handles disk-opened tables where _last_pos starts None.
+            _tbl = self._table
             if (
                 isinstance(key, slice)
                 and isinstance(value, blosc2.NDArray)
                 and not self.is_list
                 and not self.is_varlen_scalar
-                and self._table._last_pos == self._table._n_rows
+                and _tbl.base is None
+                and _tbl._resolve_last_pos() == _tbl._n_rows
             ):
-                start, stop, step = key.indices(len(self))
+                n_live = _tbl._n_rows
+                start, stop, step = key.indices(n_live)
                 chunk_size = value.chunks[0] if value.chunks else 65536
                 if self.is_ndarray:
                     spec = self._table._schema.columns_by_name[self._col_name].spec
@@ -9396,6 +9402,10 @@ def __setitem__(self, key: str, value) -> None:
             raise TypeError(
                 f"CTable.__setitem__ only accepts a column name string, got {type(key).__name__!r}"
             )
+        if self.base is not None:
+            raise ValueError("Table is a view and cannot be modified.")
+        if self._read_only:
+            raise ValueError("Table is read-only (opened with mode='r').")
         physical = self._logical_to_physical_name(key)
         if physical not in self._cols:
             raise KeyError(f"Column {key!r} does not exist; use add_column() to add new columns")
@@ -10631,6 +10641,9 @@ def extend(self, data: list | CTable | Any, *, validate: bool | None = None) ->
                     raw = raw_columns[name]
                     if isinstance(raw, blosc2.NDArray):
                         # Keep as-is; written chunk-by-chunk in the write loop below.
+                        # Note: if do_validate=True, validate_column_batch() above will
+                        # have already decompressed this column transiently for constraint
+                        # checking.  Pass validate=False to avoid that peak-memory spike.
                         scalar_processed_cols[name] = raw
                     else:
                         scalar_processed_cols[name] = np.ascontiguousarray(raw, dtype=target_dtype)

tests/ctable/test_column.py

@@ -961,6 +961,34 @@ def test_ctable_setitem_unknown_column_raises():
         t["nonexistent"] = np.zeros(20)
 
 
+def test_ctable_setitem_view_raises():
+    """t['col'] = arr on a view raises ValueError instead of silently mutating the parent."""
+    t = CTable(Row, new_data=DATA20)
+    view = t.where("id >= 0")
+    with pytest.raises(ValueError, match="view"):
+        view["score"] = np.zeros(len(view))
+
+
+def test_column_setitem_ndarray_fast_path_on_disk_table(tmp_path):
+    """Fast path fires for a disk-opened table (not just freshly-built in-memory tables)."""
+    n = 60
+    urlpath = str(tmp_path / "tbl.b2")
+
+    @dataclass
+    class R:
+        id: int = blosc2.field(blosc2.int64(ge=0))
+        val: float = blosc2.field(blosc2.float64(), default=0.0)
+
+    t = CTable(R, new_data=[(i, 0.0) for i in range(n)], urlpath=urlpath, mode="w")
+    t.close()
+
+    t2 = CTable(R, urlpath=urlpath, mode="a")
+    arr = blosc2.asarray(np.arange(n, dtype=np.float64), chunks=(16,))
+    t2["val"][:] = arr
+    np.testing.assert_array_equal(t2["val"][:], np.arange(n, dtype=np.float64))
+    t2.close()
+
+
 def test_column_setitem_blosc2_ndarray_no_holes():
     """col[:] = blosc2.NDArray takes the no-holes fast path and round-trips correctly."""
     n = 200