fix(reader)!: ArrayStats mirrors Rust's array stats table

ArrayStats.fromFbs dropped is_sorted, is_strict_sorted, is_constant,
uncompressed_size_in_bytes and nan_count, and the record carried a
trueCount the wire has no field for (Rust has no TrueCount stat: a bool
column's true count is its sum). Rust writes is_sorted/is_strict_sorted
into flat array stats, so Java read them as unknown.

The record now has one component per field of the FlatBuffer ArrayStats
table (Rust's Stat enum), in schema order; the 7-arg constructor is gone.
min_precision/max_precision are still not read: an inexact bound is still
a valid bound, so pruning stays correct.

Cross-check: vortex-jni writes an ascending id column, and every flat data
segment's peeked stats report isSorted/isStrictSorted true.

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

Author: dfa1

CHANGELOG.md

@@ -7,6 +7,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Changed
+- **Breaking:** `ArrayStats` has one component per field of Rust's array stats, so `isSorted`, `isStrictSorted`, `isConstant`, `uncompressedSizeInBytes` and `nanCount` are read from the file and `trueCount` is gone (a bool column's true count is its `sum`). ([#581](https://github.com/dfa1/vortex-java/pull/581))
+
 ## [0.18.0] — 2026-10-19
 
 ### Added

inspector/src/main/java/io/github/dfa1/vortex/inspect/InspectorTree.java

@@ -289,7 +289,7 @@ private static ArrayStats fold(List<Zone> zones) {
         if (min == null && max == null) {
             return ArrayStats.empty();
         }
-        return new ArrayStats(min, max, null, null, null, null, null);
+        return new ArrayStats(min, max, null, null, null, null, null, null, null);
     }
 
     /// The chunks of a column: the children of the first chunked node on its data path, or the

inspector/src/main/java/io/github/dfa1/vortex/inspect/VortexInspector.java

@@ -103,7 +103,7 @@ static ArrayStats aggregateStats(InspectorTree.Node node) {
         if (min == null && max == null) {
             return ArrayStats.empty();
         }
-        return new ArrayStats(min, max, null, null, null, null, null);
+        return new ArrayStats(min, max, null, null, null, null, null, null, null);
     }
 
     @SuppressWarnings({"unchecked", "rawtypes"})

inspector/src/test/java/io/github/dfa1/vortex/inspect/HtmlReportTest.java

@@ -101,7 +101,7 @@ void render_escapesUntrustedColumnNames() {
     @Test
     void render_escapesUntrustedStatValues() {
         // Given — min/max are decoded scalars from the file, so a string column can carry markup
-        InspectorTree sut = singleColumnWithStats(new ArrayStats("<b>", "\"&\"", null, null, 3L, null, null));
+        InspectorTree sut = singleColumnWithStats(new ArrayStats("<b>", "\"&\"", null, null, null, null, 3L, null, null));
 
         // When
         String result = HtmlReport.render(sut, "evil.vortex");
@@ -540,7 +540,7 @@ void render_timestampColumn_showsBoundsAsInstantsNotEpochIntegers() {
         Layout leaf = new Layout(LayoutId.parse("vortex.flat"), 2, null, List.of(), List.of(0));
         Layout root = new Layout(LayoutId.parse("vortex.struct"), 2, null, List.of(leaf), List.of());
         InspectorTree.Node leafNode = new InspectorTree.Node(leaf, Optional.of("ts"), Set.of(),
-                new ArrayStats(1_704_067_200_000L, 1_706_867_193_000L, null, null, null, null, null),
+                new ArrayStats(1_704_067_200_000L, 1_706_867_193_000L, null, null, null, null, null, null, null),
                 List.of());
         InspectorTree.Node rootNode = new InspectorTree.Node(root, Optional.empty(), Set.of(),
                 ArrayStats.empty(), List.of(leafNode));
@@ -590,7 +590,7 @@ private static InspectorTree twoColumnTree() {
         Layout root = new Layout(LayoutId.parse("vortex.struct"), 1000, null, List.of(idLeaf, valLeaf), List.of());
 
         InspectorTree.Node idNode = new InspectorTree.Node(idLeaf, Optional.of("id"),
-                Set.of("fastlanes.bitpacked"), new ArrayStats(1L, 999L, null, null, 0L, null, null), List.of());
+                Set.of("fastlanes.bitpacked"), new ArrayStats(1L, 999L, null, null, null, null, 0L, null, null), List.of());
         InspectorTree.Node valNode = new InspectorTree.Node(valLeaf, Optional.of("value"),
                 Set.of("vortex.constant"), ArrayStats.empty(), List.of());
         InspectorTree.Node rootNode = new InspectorTree.Node(root, Optional.empty(),
@@ -612,9 +612,9 @@ private static InspectorTree chunkedTree() {
         Layout root = new Layout(LayoutId.parse("vortex.struct"), 1000, null, List.of(chunked), List.of());
 
         InspectorTree.Node n0 = new InspectorTree.Node(c0, Optional.empty(), Set.of(),
-                new ArrayStats(0L, 499L, null, null, null, null, null), List.of());
+                new ArrayStats(0L, 499L, null, null, null, null, null, null, null), List.of());
         InspectorTree.Node n1 = new InspectorTree.Node(c1, Optional.empty(), Set.of(),
-                new ArrayStats(500L, 999L, null, null, null, null, null), List.of());
+                new ArrayStats(500L, 999L, null, null, null, null, null, null, null), List.of());
         InspectorTree.Node col = new InspectorTree.Node(chunked, Optional.of("id"), Set.of(),
                 ArrayStats.empty(), List.of(n0, n1));
         InspectorTree.Node rootNode = new InspectorTree.Node(root, Optional.empty(), Set.of(),

inspector/src/test/java/io/github/dfa1/vortex/inspect/VortexInspectorTest.java

@@ -135,9 +135,9 @@ void render_aggregatesMinMaxAcrossChunks() {
         Layout structLayout = new Layout(LayoutId.parse("vortex.struct"), 1000, null, List.of(chunked), List.of());
 
         InspectorTree.Node c1 = new InspectorTree.Node(chunk1, Optional.empty(), Set.of(),
-                new ArrayStats(10L, 50L, null, null, null, null, null), List.of());
+                new ArrayStats(10L, 50L, null, null, null, null, null, null, null), List.of());
         InspectorTree.Node c2 = new InspectorTree.Node(chunk2, Optional.empty(), Set.of(),
-                new ArrayStats(5L, 100L, null, null, null, null, null), List.of());
+                new ArrayStats(5L, 100L, null, null, null, null, null, null, null), List.of());
         InspectorTree.Node chunkedN = new InspectorTree.Node(chunked, Optional.of("id"),
                 Set.of("vortex.flat"), ArrayStats.empty(), List.of(c1, c2));
         InspectorTree.Node rootN = new InspectorTree.Node(structLayout, Optional.empty(),

integration/src/test/java/io/github/dfa1/vortex/integration/VortexInspectorIntegrationTest.java

@@ -6,6 +6,7 @@
 import dev.vortex.jni.NativeLoader;
 import io.github.dfa1.vortex.core.model.ColumnName;
 import io.github.dfa1.vortex.core.model.DType;
+import io.github.dfa1.vortex.reader.ArrayStats;
 import io.github.dfa1.vortex.reader.ReadRegistry;
 import io.github.dfa1.vortex.writer.WriteOptions;
 import io.github.dfa1.vortex.inspect.HtmlReport;
@@ -31,7 +32,9 @@
 import java.nio.file.StandardOpenOption;
 import java.util.Map;
 import java.nio.file.Path;
+import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 import java.util.Random;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -162,6 +165,44 @@ void htmlReport_globalDictColumn_chunkMinMaxAreValuesNotCodes(@TempDir Path tmp)
                 .contains("<td><code>cherry</code></td><td><code>date</code></td>");
     }
 
+    @Test
+    void peek_readsSortednessRustRecordsInFlatArrayStats(@TempDir Path tmp) throws IOException {
+        // Given — Rust records is_sorted/is_strict_sorted in a flat segment's array stats for an
+        // ascending integer column. Java's ArrayStats used to drop both (and carried a trueCount
+        // the wire has no field for), so these read as unknown.
+        Path file = tmp.resolve("sorted.vtx");
+        writeJni(file, 50_000);
+
+        // When
+        List<ArrayStats> result = new ArrayList<>();
+        try (VortexReader vf = VortexReader.open(file, ReadRegistry.loadAll())) {
+            InspectorTree tree = InspectorTree.buildShallow(vf);
+            InspectorTree.Node id = tree.root().children().stream()
+                    .filter(c -> c.fieldName().equals(Optional.of("id"))).findFirst().orElseThrow();
+            for (InspectorTree.Node flat : dataFlats(id)) {
+                result.add(InspectorTree.peek(flat, vf).stats());
+            }
+        }
+
+        // Then
+        assertThat(result).isNotEmpty().allSatisfy(stats -> {
+            assertThat(stats.isSorted()).isTrue();
+            assertThat(stats.isStrictSorted()).isTrue();
+        });
+    }
+
+    /// The flat segments holding a column's values: every chunk of a chunked node, else the first
+    /// child (a zoned node's second child is its zone-map table, not data).
+    private static List<InspectorTree.Node> dataFlats(InspectorTree.Node node) {
+        if (node.layout().isFlat()) {
+            return List.of(node);
+        }
+        if (node.layout().isChunked()) {
+            return node.children().stream().flatMap(c -> dataFlats(c).stream()).toList();
+        }
+        return dataFlats(node.children().getFirst());
+    }
+
     private static String[] repeat(int rows, String a, String b) {
         String[] out = new String[rows];
         for (int i = 0; i < rows; i++) {

reader/src/main/java/io/github/dfa1/vortex/reader/ArrayStats.java

@@ -7,41 +7,30 @@
 import java.lang.foreign.MemorySegment;
 import java.nio.charset.StandardCharsets;
 
-/// Per-array statistics embedded in the encoding tree.
+/// Per-array statistics embedded in the encoding tree, one component per field of the wire
+/// `ArrayStats` table (Rust's `Stat` enum). A bool column's true count is its `sum`, as in Rust.
 ///
-/// @param min            minimum value in the array, or `null` if unknown
-/// @param max            maximum value in the array, or `null` if unknown
-/// @param sum            sum of values (`Long` for integer columns, `Double` for floats), or `null` if unknown
-/// @param trueCount      number of `true` values for bool columns, or `null` if unknown
-/// @param nullCount      number of null values, or `null` if unknown
-/// @param isSorted       `true` if the array is sorted in ascending order, or `null` if unknown
-/// @param isStrictSorted `true` if the array is strictly sorted (no duplicates), or `null` if unknown
-/// @param nanCount       number of `NaN` values in a float column (`min` and `max` skip them), or `null` if unknown
+/// @param min                     minimum value in the array, or `null` if unknown
+/// @param max                     maximum value in the array, or `null` if unknown
+/// @param sum                     sum of values (`Long` for integer and bool columns, `Double` for floats), or `null` if unknown
+/// @param isSorted                `true` if the non-null values are sorted in ascending order, or `null` if unknown
+/// @param isStrictSorted          `true` if the non-null values are strictly sorted (no duplicates), or `null` if unknown
+/// @param isConstant              `true` if every value is the same (all null, or one non-null value), or `null` if unknown
+/// @param nullCount               number of null values, or `null` if unknown
+/// @param uncompressedSizeInBytes the array's uncompressed size in bytes, or `null` if unknown
+/// @param nanCount                number of `NaN` values in a float column (`min` and `max` skip them), or `null` if unknown
 public record ArrayStats(
         Object min,
         Object max,
         Object sum,
-        Long trueCount,
-        Long nullCount,
         Boolean isSorted,
         Boolean isStrictSorted,
+        Boolean isConstant,
+        Long nullCount,
+        Long uncompressedSizeInBytes,
         Long nanCount
 ) {
-    private static final ArrayStats EMPTY = new ArrayStats(null, null, null, null, null, null, null, null);
-
-    /// Creates stats with no `NaN` count.
-    ///
-    /// @param min            minimum value in the array, or `null` if unknown
-    /// @param max            maximum value in the array, or `null` if unknown
-    /// @param sum            sum of values, or `null` if unknown
-    /// @param trueCount      number of `true` values for bool columns, or `null` if unknown
-    /// @param nullCount      number of null values, or `null` if unknown
-    /// @param isSorted       `true` if the array is sorted in ascending order, or `null` if unknown
-    /// @param isStrictSorted `true` if the array is strictly sorted, or `null` if unknown
-    public ArrayStats(Object min, Object max, Object sum, Long trueCount, Long nullCount,
-                      Boolean isSorted, Boolean isStrictSorted) {
-        this(min, max, sum, trueCount, nullCount, isSorted, isStrictSorted, null);
-    }
+    private static final ArrayStats EMPTY = new ArrayStats(null, null, null, null, null, null, null, null, null);
 
     /// Returns an empty stats instance with all fields set to `null`.
     ///
@@ -51,22 +40,25 @@ public static ArrayStats empty() {
     }
 
     /// Parses stats from a FlatBuffers [io.github.dfa1.vortex.core.fbs.FbsArrayStats] table.
-    /// Returns an empty instance when `fbs` is `null` or carries no min/max and no null count.
+    /// Returns an empty instance when `fbs` is `null` or carries no statistic.
     ///
     /// @param fbs the FlatBuffers stats table, or `null`
     /// @return parsed stats, or an empty instance if no usable data is present
     public static ArrayStats fromFbs(io.github.dfa1.vortex.core.fbs.FbsArrayStats fbs) {
         if (fbs == null) {
             return EMPTY;
         }
-        Object min = decodeScalar(fbs.minAsSegment());
-        Object max = decodeScalar(fbs.maxAsSegment());
-        Object sum = decodeScalar(fbs.sumAsSegment());
-        Long nullCount = fbs.hasNullCount() ? fbs.nullCount() : null;
-        if (min == null && max == null && sum == null && nullCount == null) {
-            return EMPTY;
-        }
-        return new ArrayStats(min, max, sum, null, nullCount, null, null);
+        ArrayStats stats = new ArrayStats(
+                decodeScalar(fbs.minAsSegment()),
+                decodeScalar(fbs.maxAsSegment()),
+                decodeScalar(fbs.sumAsSegment()),
+                fbs.hasIsSorted() ? fbs.isSorted() : null,
+                fbs.hasIsStrictSorted() ? fbs.isStrictSorted() : null,
+                fbs.hasIsConstant() ? fbs.isConstant() : null,
+                fbs.hasNullCount() ? fbs.nullCount() : null,
+                fbs.hasUncompressedSizeInBytes() ? fbs.uncompressedSizeInBytes() : null,
+                fbs.hasNanCount() ? fbs.nanCount() : null);
+        return stats.equals(EMPTY) ? EMPTY : stats;
     }
 
     private static Object decodeScalar(MemorySegment seg) {

reader/src/main/java/io/github/dfa1/vortex/reader/ScanIterator.java

@@ -590,9 +590,9 @@ private List<ArrayStats> decodeZoneTable(ColumnName column, boolean includeBound
                         minA != null ? boxedScalar(minA, i) : boxedScalar(boundedMinA, i),
                         maxA != null ? boxedScalar(maxA, i) : boundedMaxScalar(boundedMaxA, i),
                         boxedScalar(sumA, i),
-                        null,
+                        null, null, null,
                         nullCount == null ? null : ((Number) nullCount).longValue(),
-                        null, null,
+                        null,
                         nanCount == null ? null : ((Number) nanCount).longValue()));
             }
             return out;

reader/src/main/java/io/github/dfa1/vortex/reader/VortexReader.java

@@ -243,8 +243,9 @@ public Map<ColumnName, ArrayStats> columnStats() {
                     // A string zone map holds only bounds (Rust's bounded_max/bounded_min), which
                     // are not exact: take min/max from the chunks' own array stats instead.
                     ArrayStats exact = aggregateStats(iter.chunkStats(name), column);
-                    stats = new ArrayStats(exact.min(), exact.max(), stats.sum(), stats.trueCount(),
-                            stats.nullCount(), stats.isSorted(), stats.isStrictSorted());
+                    stats = new ArrayStats(exact.min(), exact.max(), stats.sum(), stats.isSorted(),
+                            stats.isStrictSorted(), stats.isConstant(), stats.nullCount(),
+                            stats.uncompressedSizeInBytes(), stats.nanCount());
                 }
                 result.put(name, stats);
             }
@@ -278,7 +279,7 @@ private ArrayStats aggregateStats(List<ArrayStats> zones, DType column) {
         }
         // Sum is left null at the file level: it lives in the per-zone stats table, surfaced by
         // ScanIterator.columnZoneStats rather than folded here.
-        return new ArrayStats(globalMin, globalMax, null, null, nullCount, null, null);
+        return new ArrayStats(globalMin, globalMax, null, null, null, null, nullCount, null, null);
     }
 
     @Override

reader/src/test/java/io/github/dfa1/vortex/reader/ArrayStatsTest.java

@@ -29,10 +29,13 @@ void hasAllNullComponents() {
             // Then
             assertThat(sut.min()).isNull();
             assertThat(sut.max()).isNull();
-            assertThat(sut.trueCount()).isNull();
-            assertThat(sut.nullCount()).isNull();
+            assertThat(sut.sum()).isNull();
             assertThat(sut.isSorted()).isNull();
             assertThat(sut.isStrictSorted()).isNull();
+            assertThat(sut.isConstant()).isNull();
+            assertThat(sut.nullCount()).isNull();
+            assertThat(sut.uncompressedSizeInBytes()).isNull();
+            assertThat(sut.nanCount()).isNull();
         }
     }
 
@@ -192,6 +195,34 @@ void emptyByteVector_treatedAsAbsent() {
             assertThat(sut).isSameAs(ArrayStats.empty());
         }
 
+        @Test
+        void everyWireField_decodes() {
+            // Given — every field of the wire table, with false/0 values on purpose: they equal the
+            // FlatBuffer scalar defaults, so a reader that skips a field or tests the value instead
+            // of its presence reads them as unknown. A dropped nan_count = 0 made every float chunk
+            // look NaN-capped, so its max never pruned.
+            FbsBuilder b = new FbsBuilder(128);
+            int sumOff = io.github.dfa1.vortex.core.fbs.FbsArrayStats.createSumVector(
+                    b, ProtoScalarValue.ofInt64Value(12L).encode());
+            b.forceDefaults(true);
+            io.github.dfa1.vortex.core.fbs.FbsArrayStats.startFbsArrayStats(b);
+            io.github.dfa1.vortex.core.fbs.FbsArrayStats.addSum(b, sumOff);
+            io.github.dfa1.vortex.core.fbs.FbsArrayStats.addIsSorted(b, true);
+            io.github.dfa1.vortex.core.fbs.FbsArrayStats.addIsStrictSorted(b, false);
+            io.github.dfa1.vortex.core.fbs.FbsArrayStats.addIsConstant(b, false);
+            io.github.dfa1.vortex.core.fbs.FbsArrayStats.addNullCount(b, 0L);
+            io.github.dfa1.vortex.core.fbs.FbsArrayStats.addUncompressedSizeInBytes(b, 800L);
+            io.github.dfa1.vortex.core.fbs.FbsArrayStats.addNanCount(b, 0L);
+            b.finish(io.github.dfa1.vortex.core.fbs.FbsArrayStats.endFbsArrayStats(b));
+            var fbs = io.github.dfa1.vortex.core.fbs.FbsArrayStats.getRootAsFbsArrayStats(b.dataSegment());
+
+            // When
+            ArrayStats result = ArrayStats.fromFbs(fbs);
+
+            // Then
+            assertThat(result).isEqualTo(new ArrayStats(null, null, 12L, true, false, false, 0L, 800L, 0L));
+        }
+
         @Test
         void malformedScalarBytes_throwsVortexException() {
             // Given — varint tag with no continuation byte: ProtoReader hits EOF inside readVarint