fix(reader): skip the copy when vortex.patched has no patches

PatchedEncodingDecoder allocated n * elemBytes and broadcastCopy'd the
inner child into it unconditionally, then applied patches only when
there were any. With nPatches == 0 the result is byte-for-byte the inner
child, which had just come from decodeChildSegment and is already
arena-lifetime — so the decoder paid a full column copy to produce a
duplicate. A zero-patch node is not exotic: a bitpacked column whose
exception list happens to be empty for a chunk still round-trips through
this encoding.

The copy is not always avoidable. An inner child holding fewer than n
elements is the ConstantEncoding fan-out that broadcastCopy exists for,
so the alias is taken only when the child covers every row; the guard
tests capacity, not just nPatches. The child is sliced to exactly n
elements so the Materialized* accessors keep their
`length == elementCount` fast path when the buffer runs long, and
returned read-only, matching the sibling decoders.

Tests assert the aliasing directly rather than just the values — the
existing no-patch test passes either way — by mutating the source buffer
after decode and observing the change, plus the two guard edges (inner
longer than the row count, inner shorter than it).

Closes #337

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: dfa1

CHANGELOG.md

@@ -12,6 +12,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - A run-end-encoded Utf8/Binary column (`vortex.runend`) no longer expands every run into a fully materialized buffer on decode; rows now resolve through the runs lazily, removing an unbounded `sum(runLength * valueLength)` allocation that a crafted file could drive to `OutOfMemoryError`. ([#334](https://github.com/dfa1/vortex-java/issues/334))
 - A `vortex.sequence` column no longer materializes `base + i * multiplier` into a full buffer on decode; rows are computed on access, so the encoding allocates nothing regardless of row count — closing an `OutOfMemoryError` risk from a metadata-only encoding whose row count no buffer bounds. ([#335](https://github.com/dfa1/vortex-java/issues/335))
 - A primitive `vortex.dict` column decoded through the encoding path no longer expands its codes into an `n * elemSize` buffer; it now returns the same lazy `DictXxxArray` carriers the layout path already used, so a dict column keeps the dictionary's memory benefit however it is reached. ([#336](https://github.com/dfa1/vortex-java/issues/336))
+- A `vortex.patched` column with no patches no longer allocates and copies a full duplicate of its inner child; the child is aliased directly when it already covers every row. ([#337](https://github.com/dfa1/vortex-java/issues/337))
 
 ## [0.13.1] — 2026-08-06
 

reader/src/main/java/io/github/dfa1/vortex/reader/decode/PatchedEncodingDecoder.java

@@ -66,13 +66,8 @@ public Array decode(DecodeContext ctx) {
                 DType.U16, nPatches);
         MemorySegment patchValuesSeg = ctx.decodeChildSegment(3, ctx.dtype(), nPatches);
 
-        MemorySegment out = ctx.arena().allocate(n * elemBytes);
-        SegmentBroadcast.broadcastCopy(innerSeg, out, n, elemBytes);
-
-        if (nPatches > 0) {
-            applyPatches(out, n, nChunks, nLanes, offset, elemBytes,
-                    laneOffsetsSeg, patchIndicesSeg, patchValuesSeg);
-        }
+        MemorySegment out = patchedOutput(ctx, innerSeg, n, elemBytes, nPatches,
+                nChunks, nLanes, offset, laneOffsetsSeg, patchIndicesSeg, patchValuesSeg);
 
         return switch (ptype) {
             case I8, U8 -> new MaterializedByteArray(ctx.dtype(), n, out);
@@ -86,6 +81,47 @@ public Array decode(DecodeContext ctx) {
         };
     }
 
+    /// Produces the patched values buffer.
+    ///
+    /// With no patches to apply, the result is byte-for-byte the inner child, so allocating
+    /// `n * elemBytes` and copying into it produces a duplicate and nothing else — the inner
+    /// segment is already arena-lifetime, having just come from `decodeChildSegment`. A
+    /// zero-patch `vortex.patched` node is not exotic: a bitpacked column whose exception list
+    /// happens to be empty for a chunk still round-trips through this encoding.
+    ///
+    /// The copy is still required when the inner child holds fewer than `n` elements — the
+    /// `ConstantEncoding` fan-out that [SegmentBroadcast#broadcastCopy] exists for — so the
+    /// alias is taken only when the child covers every row. It is sliced to exactly `n`
+    /// elements so the `Materialized*` accessors keep their `length == elementCount` fast path
+    /// even when the child buffer runs long.
+    ///
+    /// @param ctx             decode context (allocation arena)
+    /// @param innerSeg        decoded inner child
+    /// @param n               logical row count
+    /// @param elemBytes       value element width
+    /// @param nPatches        number of patches declared by the metadata
+    /// @param nChunks         number of 1024-row chunks spanned
+    /// @param nLanes          lanes per chunk
+    /// @param offset          starting absolute position
+    /// @param laneOffsetsSeg  per-chunk lane offsets
+    /// @param patchIndicesSeg per-patch in-chunk indices
+    /// @param patchValuesSeg  per-patch replacement values
+    /// @return the values buffer, aliased to `innerSeg` when there is nothing to patch
+    private static MemorySegment patchedOutput(DecodeContext ctx, MemorySegment innerSeg, long n, int elemBytes,
+            long nPatches, long nChunks, long nLanes, long offset,
+            MemorySegment laneOffsetsSeg, MemorySegment patchIndicesSeg, MemorySegment patchValuesSeg) {
+        if (nPatches == 0 && SegmentBroadcast.capacity(innerSeg, elemBytes) >= n) {
+            return innerSeg.asSlice(0, n * elemBytes).asReadOnly();
+        }
+        MemorySegment out = ctx.arena().allocate(n * elemBytes);
+        SegmentBroadcast.broadcastCopy(innerSeg, out, n, elemBytes);
+        if (nPatches > 0) {
+            applyPatches(out, n, nChunks, nLanes, offset, elemBytes,
+                    laneOffsetsSeg, patchIndicesSeg, patchValuesSeg);
+        }
+        return out;
+    }
+
     private static void applyPatches(
             MemorySegment out, long n, long nChunks, long nLanes, long offset, int elemBytes,
             MemorySegment laneOffsets, MemorySegment patchIndices, MemorySegment patchValues

reader/src/test/java/io/github/dfa1/vortex/reader/decode/PatchedEncodingDecoderTest.java

@@ -3,6 +3,7 @@
 import io.github.dfa1.vortex.core.testing.TestSegments;
 import io.github.dfa1.vortex.reader.ReadRegistry;
 
+import io.github.dfa1.vortex.core.io.VortexFormat;
 import io.github.dfa1.vortex.core.model.DType;
 import io.github.dfa1.vortex.reader.array.Array;
 import io.github.dfa1.vortex.reader.array.IntArray;
@@ -77,6 +78,66 @@ void decode_noPatches_returnsInnerUnchanged() {
         }
     }
 
+    /// With nothing to patch, the output is byte-for-byte the inner child, so the decoder must
+    /// alias it rather than allocate `n * elemBytes` and copy into a duplicate (#337). Proven by
+    /// mutating the source after decode: a copy would not see the change.
+    @Test
+    void decode_noPatches_aliasesTheInnerChildInsteadOfCopying() {
+        // Given — a mutable inner buffer, so a later write reveals whether it was copied
+        byte[] backing = new byte[4 * Integer.BYTES];
+        MemorySegment inner = MemorySegment.ofArray(backing);
+        for (int i = 0; i < 4; i++) {
+            inner.setAtIndex(VortexFormat.LE_INT, i, (i + 1) * 10);
+        }
+
+        // When
+        Array result = decodeNoPatches(inner, 4);
+        inner.setAtIndex(VortexFormat.LE_INT, 2, 999);
+
+        // Then
+        assertThat(((IntArray) result).getInt(2)).isEqualTo(999);
+    }
+
+    /// An inner child longer than the row count is sliced to exactly `n` elements, so the
+    /// `Materialized*` accessors keep their `length == elementCount` fast path instead of
+    /// falling into the broadcast-modulo branch.
+    @Test
+    void decode_noPatches_innerLongerThanRowCount_isSlicedToRowCount() {
+        // Given — 6 elements on the wire, 4 rows declared
+        MemorySegment inner = TestSegments.leInts(10, 20, 30, 40, 50, 60);
+
+        // When
+        Array result = decodeNoPatches(inner, 4);
+
+        // Then
+        assertThat(result.length()).isEqualTo(4L);
+        assertThat(result.segmentIfPresent()).hasValueSatisfying(
+                seg -> assertThat(seg.byteSize()).isEqualTo(4L * Integer.BYTES));
+        assertThat(((IntArray) result).getInt(3)).isEqualTo(40);
+    }
+
+    /// The alias is only safe when the child covers every row. A `ConstantEncoding` child holds
+    /// one element for any row count, so that case must still fan out through the copy.
+    @Test
+    void decode_noPatches_undersizedInner_stillBroadcasts() {
+        // Given — a single inner element for 4 rows
+        MemorySegment inner = TestSegments.leInts(7);
+
+        // When
+        Array result = decodeNoPatches(inner, 4);
+
+        // Then
+        IntArray ints = (IntArray) result;
+        for (int i = 0; i < 4; i++) {
+            assertThat(ints.getInt(i)).as("index %d", i).isEqualTo(7);
+        }
+    }
+
+    private static Array decodeNoPatches(MemorySegment inner, int n) {
+        return decode(DType.I32, n, inner, TestSegments.leInts(0, 0),
+                TestSegments.leShorts(), TestSegments.leInts(), 1);
+    }
+
     @Test
     void decode_singlePatch_overwrites() {
         // Given / When