0.8.2: writeSeries() accumulates seriesRowCount across multiple calls

When LastraWriter.writeSeries(rowCount, ...) is called more than once on the
same writer (streaming-append usage), each call previously REPLACED the total
seriesRowCount instead of adding to it. The footer therefore recorded only
the last call's count, and full-series reads via readSeriesLong/Double tripped
ArrayIndexOutOfBoundsException because the result buffer was sized from that
under-count while per-RG arraycopy fed it the full data.

Single-call usage (the auto-partitioned multi-RG path already covered by
testRowGroupsAutoPartitioning) is unaffected — the field starts at 0 and one
call adds its rowCount, total equals rowCount.

Per-RG reads (readRowGroupLong/Double, rowGroupStats(g)) were already correct
in 0.8.1 — only the aggregate seriesRowCount was wrong.

Tests: new testMultipleWriteSeriesCallsAccumulate (4 × writeSeries(100,...))
verifies the running total, per-RG stats per call, and concatenated full read.
26/26 suite green.

Author: mrmx

Changelog/2026-05-06T09-15_v0.8.2_writeSeries_accumulate_seriesRowCount.md

@@ -0,0 +1,50 @@
+# 0.8.2 — writeSeries() accumulates seriesRowCount across calls
+
+**Date**: 2026-05-06
+
+## What
+
+`LastraWriter.writeSeries(int rowCount, Object... columnData)` can be invoked
+multiple times to append successive chunks to the same series — each call
+becomes one or more row groups, and the reader sees them concatenated. Until
+0.8.1, however, every call **replaced** `seriesRowCount` with its own
+`rowCount` rather than adding to the running total. The footer therefore
+recorded only the last call's count.
+
+Downstream effect: `LastraReader.readSeriesLong/Double` allocates the result
+array as `new T[seriesRowCount]`, then `arraycopy`'s every row group into it.
+With a buggy total, the second RG's bytes overran the array — `arraycopy`
+threw `ArrayIndexOutOfBoundsException`. Per-RG reads
+(`readRowGroupLong/Double(g, name)`) and per-RG stats (`rowGroupStats(g)`)
+were already correct.
+
+## Fix
+
+```java
+public LastraWriter writeSeries(int rowCount, Object... columnData) {
+-   this.seriesRowCount = rowCount;
++   this.seriesRowCount += rowCount;
+```
+
+## Compatibility
+
+- Single-call usage (the common case, including everything written by
+  lastra-java ≤ 0.8.1) is unaffected — the field is initialised to 0, the
+  call adds `rowCount`, total equals `rowCount`.
+- Files produced by 0.8.1 with multiple `writeSeries` calls have an
+  under-counted `seriesRowCount` in the footer; those files cannot be safely
+  fully read via `readSeriesLong/Double`. Per-RG reads still work.
+  Re-encoding from source data through 0.8.2 produces a file with the
+  correct total.
+
+## Tests
+
+New `LastraRoundtripTest.testMultipleWriteSeriesCallsAccumulate`:
+- 4 calls × `writeSeries(100, ts, v)` with `setRowGroupSize(100)`.
+- Asserts: `rowGroupCount=4`, `seriesRowCount=400`, per-RG stats bound to
+  each call's slice, full-series read returns the 400 rows in order, and
+  `readRowGroupLong(2, "ts")` returns the third call's 100-row slice.
+
+Reproduces against 0.8.1 (`expected: 400 but was: 100`); passes on 0.8.2.
+
+All 26 unit tests across the suite green on 0.8.2.

pom.xml

@@ -5,7 +5,7 @@
 
     <groupId>com.wualabs.qtsurfer</groupId>
     <artifactId>lastra</artifactId>
-    <version>0.8.1</version>
+    <version>0.8.2</version>
     <packaging>jar</packaging>
 
     <name>Lastra</name>

src/main/java/com/wualabs/qtsurfer/lastra/LastraWriter.java

@@ -115,7 +115,9 @@ public LastraWriter setRowGroupSize(int size) {
      * {@code double[]} for DOUBLE, {@code byte[][]} for BINARY.
      */
     public LastraWriter writeSeries(int rowCount, Object... columnData) {
-        this.seriesRowCount = rowCount;
+        // Accumulate across calls — each invocation appends rows to the same series rather
+        // than replacing it. The footer's series row count must reflect the total written.
+        this.seriesRowCount += rowCount;
 
         // Partition into row groups
         for (int start = 0; start < rowCount; start += rowGroupSize) {

src/test/java/com/wualabs/qtsurfer/lastra/LastraRoundtripTest.java

@@ -476,6 +476,74 @@ void testCloseIsIdempotent() throws Exception {
         assertThat(r.readSeriesLong("ts")).containsExactly(ts);
     }
 
+    /**
+     * Streaming-append usage: caller invokes {@link LastraWriter#writeSeries} multiple times,
+     * each call carrying the next chunk of the series. The single-call variant is already
+     * covered by {@link #testRowGroupsAutoPartitioning} (one writeSeries → auto-partitioned
+     * into N RGs by rgSize). This case is the dual: K calls, each {@code writeSeries(rgSize)}
+     * produces one RG, and the reader sees K RGs whose concatenated content equals the union.
+     *
+     * <p>Verifies on the writer side: {@link LastraReader#seriesRowCount} reports the SUM of
+     * rows across calls (not just the last call), {@link LastraReader#rowGroupCount} reports K,
+     * each RG's stats are bound to its slice, and {@link LastraReader#readSeriesLong} /
+     * {@code readSeriesDouble} return all K*rgSize values in chronological order.
+     */
+    @Test
+    void testMultipleWriteSeriesCallsAccumulate() throws Exception {
+        int rgSize = 100;
+        int rgCount = 4;
+        long t0 = 1_700_000_000_000L;
+        long hourMs = 3_600_000L;
+
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        try (LastraWriter w = new LastraWriter(baos)) {
+            w.addSeriesColumn("ts", Lastra.DataType.LONG, Lastra.Codec.DELTA_VARINT);
+            w.addSeriesColumn("v", Lastra.DataType.DOUBLE, Lastra.Codec.ALP);
+            w.setRowGroupSize(rgSize);
+            for (int g = 0; g < rgCount; g++) {
+                long[] ts = new long[rgSize];
+                double[] v = new double[rgSize];
+                for (int i = 0; i < rgSize; i++) {
+                    ts[i] = t0 + g * hourMs + i;
+                    v[i] = 100.0 + g + i * 0.01;
+                }
+                w.writeSeries(rgSize, ts, v);
+            }
+        }
+
+        LastraReader r = LastraReader.from(baos.toByteArray());
+        int totalRows = rgCount * rgSize;
+
+        assertThat(r.rowGroupCount()).as("rgCount").isEqualTo(rgCount);
+        assertThat(r.seriesRowCount())
+                .as("seriesRowCount must be the sum across writeSeries() calls")
+                .isEqualTo(totalRows);
+
+        // Per-RG stats: each call produces one RG with its own time bounds.
+        for (int g = 0; g < rgCount; g++) {
+            RowGroupStats s = r.rowGroupStats(g);
+            assertThat(s.rowCount()).as("rg %d rowCount", g).isEqualTo(rgSize);
+            assertThat(s.tsMin()).as("rg %d tsMin", g).isEqualTo(t0 + g * hourMs);
+            assertThat(s.tsMax()).as("rg %d tsMax", g).isEqualTo(t0 + g * hourMs + (rgSize - 1));
+        }
+
+        // Whole-series read returns all rows from all RGs in order.
+        long[] ts = r.readSeriesLong("ts");
+        double[] v = r.readSeriesDouble("v");
+        assertThat(ts).hasSize(totalRows);
+        assertThat(v).hasSize(totalRows);
+        assertThat(ts[0]).isEqualTo(t0);
+        assertThat(ts[rgSize]).as("first ts of RG #2").isEqualTo(t0 + hourMs);
+        assertThat(ts[totalRows - 1]).isEqualTo(t0 + (rgCount - 1) * hourMs + (rgSize - 1));
+        assertThat(v[0]).isEqualTo(100.0);
+        assertThat(v[totalRows - 1]).isEqualTo(100.0 + (rgCount - 1) + (rgSize - 1) * 0.01);
+
+        // Per-RG read returns exactly that RG's slice.
+        long[] rg2Ts = r.readRowGroupLong(2, "ts");
+        assertThat(rg2Ts).hasSize(rgSize);
+        assertThat(rg2Ts[0]).isEqualTo(t0 + 2 * hourMs);
+    }
+
     private static void assertBitExact(double[] actual, double[] expected) {
         assertThat(actual).hasSize(expected.length);
         for (int i = 0; i < expected.length; i++) {