@@ -666,6 +666,31 @@ def test_in_memory_table_shares_the_dataset_s_memory(chunks):
     assert ctx.sql("SELECT w FROM t").to_pandas()["w"].tolist() == [7.0] * 24
 
 
+@pytest.mark.parametrize(
+    "values, written",
+    [
+        (np.asfortranarray(np.zeros((4, 6))), 7.0),
+        (np.zeros((6, 4)).T, 7.0),
+        (np.zeros((4, 12))[:, ::2], 7.0),
+        (np.zeros((4, 6), dtype=bool), True),
+        (np.full((4, 6), "a"), "b"),
+    ],
+    ids=["fortran-order", "transposed", "strided", "bool", "str"],
+)
+def test_in_place_write_shows_where_arrow_would_copy(values, written):
+    """A write in place shows in the next query even for an array whose
+    Arrow column would be a copy, which isn't an in-memory table."""
+    ds = xr.Dataset({"w": (("a", "b"), values)})
+    ctx = XarrayContext()
+    ctx.from_dataset("t", ds)
+
+    ds["w"].values[...] = written
+
+    assert (
+        ctx.sql("SELECT w FROM t").to_pandas()["w"].tolist() == [written] * 24
+    )
+
+
 def test_in_memory_dataset_over_the_limit_in_arrow_is_read_lazily():
     """The 64 MiB limit is on the table as Arrow, which a long string can
     exceed when an estimate of its size doesn't."""
 
@@ -222,6 +222,23 @@ def _arrow_size(schema: pa.Schema, num_rows: int) -> int:
     return num_rows * sum(widths)
 
 
+def _shares_memory_with_arrow(values: np.ndarray) -> bool:
+    """Whether ``values``'s Arrow column, its rows in C order, can be its
+    own memory rather than a copy.
+
+    Arrow lays out a number or a datetime as NumPy does, in the machine's
+    byte order. It packs booleans into bits, and keeps strings in buffers
+    of its own, so those are copies; so is an array that isn't
+    C-contiguous, such as one in Fortran order or a transposed or strided
+    view, whose rows in C order aren't one run of memory.
+    """
+    return (
+        values.dtype.kind in "iufmM"
+        and values.dtype.isnative
+        and values.flags.c_contiguous
+    )
+
+
 def _in_memory_partitions(
     ds: xr.Dataset,
     chunks: Chunks = None,
@@ -241,23 +258,29 @@ def _in_memory_partitions(
 
     The rows are in C order, and each partition is a contiguous range of
     them, as many partitions as ``chunks`` makes chunks, up to the number
-    of CPUs. So a data variable whose array is C-contiguous isn't copied,
-    whatever the chunks: its Arrow column shares the array's memory, as
-    does DataFusion's table, through Arrow's C data interface. A NaN adds a
-    validity bitmap beside it, one bit per value, made here: a NaN written
-    into the array later isn't read as NULL. What the table adds is its
-    dimension columns, one value per row for each dimension, which
-    long-form rows need. An array that isn't C-contiguous (Fortran order)
-    is copied, once.
-
-    Returns ``None`` for a Dataset that isn't in memory (a Dask array or a
-    lazily loaded file), is larger than ``limit``, or has no rows; it is
-    read lazily instead.
+    of CPUs. So no data variable is copied, whatever the chunks: its Arrow
+    column shares the array's memory, as does DataFusion's table, through
+    Arrow's C data interface, and a write into the array in place shows in
+    the next query, as it does for a lazy table. A NaN adds a validity
+    bitmap beside it, one bit per value, made here: a NaN written into the
+    array later isn't read as NULL. What the table adds is its dimension
+    columns, one value per row for each dimension, which long-form rows
+    need.
+
+    Returns ``None``, for the Dataset to be read lazily instead, when it
+    isn't in memory (a Dask array or a lazily loaded file), is larger than
+    ``limit``, or has no rows; or when a data variable's Arrow column
+    would have to be a copy of its array, which a write in place wouldn't
+    reach (see `_shares_memory_with_arrow`).
     """
     # `_in_memory` is xarray's own test for a variable whose values are
     # loaded: a NumPy array, not a Dask array or a lazily indexed file.
     if not all(var._in_memory for var in ds.variables.values()):
         return None
+    if not all(
+        _shares_memory_with_arrow(var.values) for var in ds.data_vars.values()
+    ):
+        return None
     # TODO(#286): register a dimension that no data variable has (only a
     # coordinate does) as the lazy reader should, then drop this fallback.
     data_vars = list(ds.data_vars.values())
 
@@ -80,9 +80,9 @@ def from_dataset(
         A Dataset is read lazily, chunk by chunk, as queries run. One
         already in memory (NumPy, not Dask or a lazily opened file) and at
         most 64 MiB as a table is instead a DataFusion in-memory table,
-        which is faster to scan many times. It shares the Dataset's memory,
-        so changing values in place changes what queries return, as long
-        as no value becomes or stops being NaN (which reads as NULL).
+        which is faster to scan many times. Either way, changing values in
+        place changes what queries return, as long as no value becomes or
+        stops being NaN (which reads as NULL) in an in-memory table.
 
         For datasets with non-Gregorian cftime coordinates (e.g. 360_day,
         julian), a ``cftime()`` scalar UDF is automatically registered so