@@ -647,3 +647,17 @@ def test_large_in_memory_dataset_is_read_lazily():
     ctx.from_dataset("big", ds)
 
     assert "XarrayScanExec" in _scans(ctx, "big")
+
+
+@pytest.mark.parametrize("chunks", [None, {"a": 2}, {"b": 3}, {"a": 2, "b": 2}])
+def test_in_memory_table_shares_the_dataset_s_memory(chunks):
+    """A native table reads the Dataset's arrays, not a copy, whatever the
+    chunks: a change made in place shows in the next query, as it does for
+    a lazy table."""
+    ds = xr.Dataset({"w": (("a", "b"), np.zeros((4, 6)))})
+    ctx = XarrayContext()
+    ctx.from_dataset("t", ds, chunks=chunks)
+
+    ds["w"].values[...] = 7.0
+
+    assert ctx.sql("SELECT w FROM t").to_pandas()["w"].tolist() == [7.0] * 24
@@ -10,6 +10,7 @@
 
 from __future__ import annotations
 
+import os
 from collections.abc import Callable, Iterator
 from typing import TYPE_CHECKING
 
@@ -223,8 +224,16 @@ def _in_memory_partitions(
     DataFusion inlines a CTE or a view at every place that reads it. A
     Dataset that is already in memory gains nothing from being read lazily,
     so when it is also at most ``limit`` bytes as long-form Arrow, its rows
-    are converted once, one partition per chunk, for a native in-memory
-    table.
+    are converted once, for a native in-memory table.
+
+    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. 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
@@ -239,10 +248,26 @@ def _in_memory_partitions(
     num_rows = int(np.prod([ds.sizes[d] for d in ds.dims]))
     if num_rows == 0 or _arrow_size(schema, num_rows) > limit:
         return None
-    resolved = resolve_chunks(ds, chunks)
+    # A partition per chunk, for the parallelism the lazy table has, but cut
+    # from the rows rather than by `isel`: a chunk of a trailing dimension
+    # isn't contiguous in memory, and flattening it would copy. More
+    # partitions than cores only adds overhead, since an in-memory table has
+    # no partitions to prune.
+    count = min(
+        sum(
+            1
+            for _ in _block_slices_from_resolved(ds, resolve_chunks(ds, chunks))
+        ),
+        os.cpu_count() or 1,
+    )
+    # `per_partition` batches of `size` rows each make `count` partitions,
+    # with no batch over `batch_size` rows.
+    per_partition = -(-num_rows // (count * batch_size))
+    size = -(-num_rows // (count * per_partition))
+    batches = list(iter_record_batches(ds, schema, size))
     return [
-        list(iter_record_batches(ds.isel(block), schema, batch_size))
-        for block in _block_slices_from_resolved(ds, resolved)
+        batches[i : i + per_partition]
+        for i in range(0, len(batches), per_partition)
     ]
 
 
 
@@ -77,11 +77,13 @@ def from_dataset(
 
         A Dataset is read lazily, chunk by chunk, as queries run, unless it
         is already in memory (NumPy arrays, not Dask or a lazily opened
-        file) and at most 64 MiB as a table. Such a Dataset is converted
-        to Arrow once, here, and registered as a native DataFusion
-        in-memory table, which is faster to scan many times, as a query
-        does when it reads a table in several places. It is held twice,
-        as arrays and as Arrow.
+        file) and at most 64 MiB as a table. Such a Dataset is registered
+        as a native DataFusion in-memory table, which is faster to scan
+        many times, as a query does when it reads a table in several
+        places. The table shares its data variables' memory with the
+        Dataset rather than copying it, so, as with a lazy table, changing
+        the Dataset's values in place changes what queries return. It adds
+        a column per dimension, one value per row.
 
         For datasets with non-Gregorian cftime coordinates (e.g. 360_day,
         julian), a ``cftime()`` scalar UDF is automatically registered so