feat: add VarBinCodec and symbol column benchmark

- VarBinCodec decodes vortex.varbin (bytes + I32/I64 offsets)
- ConstantCodec.decodeString: O(1) bytes via alternating offsets into
  single shared buffer instead of n copies
- RustVsJavaReadBenchmark: add jniReadSymbol/javaReadSymbol (UTF-8)
  and jniReadClose/javaReadClose (ALP F64)
- README: add symbol row to benchmark table (Java 2.5× vs JNI)

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

Author: dfa1

README.md

@@ -8,15 +8,17 @@ Pure-Java reader/writer for the [Vortex](https://github.com/spiraldb/vortex) col
 
 `RustVsJavaReadBenchmark` — 10M OHLC rows, JMH throughput (higher = better), Apple M-series, Java 25:
 
-| Column          | Encoding      | vortex-jni  | vortex-java  | ratio         |
-|-----------------|---------------|-------------|--------------|---------------|
-| `volume` (I64)  | primitive     | 51.9 ops/s  | 120.7 ops/s  | **Java 2.3×** |
-| `close` (F64)   | ALP           | 62.6 ops/s  | 118.0 ops/s  | **Java 1.9×** |
-
-Both columns decoded faster in pure Java than via JNI + Apache Arrow. Key optimisations on
-the ALP path: `static final` ValueLayout constants (JIT constant-folding), aligned arena
-allocation (`allocate(n, alignment)`), and `getAtIndex()`/`setAtIndex()` instead of raw byte
-offsets (clearer stride for the auto-vectoriser).
+| Column           | Encoding          | vortex-jni  | vortex-java  | ratio         |
+|------------------|-------------------|-------------|--------------|---------------|
+| `volume` (I64)   | primitive         | 51.9 ops/s  | 120.7 ops/s  | **Java 2.3×** |
+| `close` (F64)    | ALP               | 62.6 ops/s  | 118.0 ops/s  | **Java 1.9×** |
+| `symbol` (UTF-8) | constant (varbin) | 10.9 ops/s  | 27.8 ops/s   | **Java 2.5×** |
+
+All columns decoded faster in pure Java than via JNI + Apache Arrow. Key optimisations:
+`static final` ValueLayout constants (JIT constant-folding), aligned arena allocation
+(`allocate(n, alignment)`), `getAtIndex()`/`setAtIndex()` (clearer stride for the
+auto-vectoriser), and O(1) bytes allocation for constant strings (alternating offsets
+into a single shared byte buffer).
 
 ## Motivation
 

core/src/main/java/io/github/dfa1/vortex/encoding/ConstantCodec.java

@@ -11,6 +11,7 @@
 import java.lang.foreign.ValueLayout;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
+import java.nio.charset.StandardCharsets;
 
 /// Decoder for {@code vortex.constant} — all elements share the same value.
 ///
@@ -56,10 +57,6 @@ public EncodeResult encode(DType dtype, Object data) {
 
 	@Override
 	public Array decode(DecodeContext ctx) {
-		if (!(ctx.dtype() instanceof DType.Primitive p)) {
-			throw new IllegalStateException("vortex.constant: expected primitive dtype, got " + ctx.dtype());
-		}
-
 		MemorySegment scalarBuf = ctx.buffer(0);
 		byte[] scalarBytes = scalarBuf.toArray(ValueLayout.JAVA_BYTE);
 
@@ -70,8 +67,17 @@ public Array decode(DecodeContext ctx) {
 			throw new IllegalStateException("vortex.constant: invalid scalar value", e);
 		}
 
-		PType ptype = p.ptype();
 		long n = ctx.rowCount();
+
+		if (ctx.dtype() instanceof DType.Utf8 || ctx.dtype() instanceof DType.Binary) {
+			return decodeString(ctx, scalar, n);
+		}
+
+		if (!(ctx.dtype() instanceof DType.Primitive p)) {
+			throw new IllegalStateException("vortex.constant: unsupported dtype " + ctx.dtype());
+		}
+
+		PType ptype = p.ptype();
 		int elemBytes = ptype.byteSize();
 		long rawBits = scalarToRawBits(scalar, ptype);
 
@@ -84,4 +90,33 @@ public Array decode(DecodeContext ctx) {
 		return new Array(ctx.dtype(), n,
 				new MemorySegment[]{outSeg.asReadOnly()}, Array.NO_CHILDREN, ArrayStats.empty());
 	}
+
+	private static Array decodeString(DecodeContext ctx, ScalarProtos.ScalarValue scalar, long n) {
+		byte[] strBytes = scalar.hasStringValue()
+				? scalar.getStringValue().getBytes(StandardCharsets.UTF_8)
+				: scalar.getBytesValue().toByteArray();
+
+		int strLen = strBytes.length;
+
+		// Store the string bytes once; all n offsets point into the same [0, strLen] range.
+		// Offsets layout: [0, strLen, 0, strLen, ...] — each pair encodes the same slice.
+		MemorySegment bytesSeg = ctx.arena().allocate(strLen);
+		MemorySegment.copy(MemorySegment.ofArray(strBytes), 0, bytesSeg, 0, strLen);
+
+		// Offsets: n+1 I32 values, alternating start/end of the single string.
+		MemorySegment offsetsSeg = ctx.arena().allocate((n + 1) * 4L, 4);
+		var layout = ValueLayout.JAVA_INT_UNALIGNED.withOrder(ByteOrder.LITTLE_ENDIAN);
+		for (long i = 0; i <= n; i++) {
+			// even index → 0 (start), odd → strLen (end); wraps back to 0 for the next string's start
+			offsetsSeg.setAtIndex(layout, i, (i % 2 == 0) ? 0 : strLen);
+		}
+
+		Array offsets = new Array(new DType.Primitive(PType.I32, false), n + 1,
+				new MemorySegment[]{offsetsSeg.asReadOnly()}, Array.NO_CHILDREN, ArrayStats.empty());
+
+		return new Array(ctx.dtype(), n,
+				new MemorySegment[]{bytesSeg.asReadOnly()},
+				new Array[]{offsets},
+				ArrayStats.empty());
+	}
 }

core/src/main/java/io/github/dfa1/vortex/encoding/VarBinCodec.java

@@ -0,0 +1,70 @@
+package io.github.dfa1.vortex.encoding;
+
+import com.google.protobuf.InvalidProtocolBufferException;
+import dev.vortex.proto.EncodingProtos;
+import io.github.dfa1.vortex.core.Array;
+import io.github.dfa1.vortex.core.ArrayStats;
+import io.github.dfa1.vortex.core.DType;
+import io.github.dfa1.vortex.core.PType;
+
+import java.lang.foreign.MemorySegment;
+import java.nio.ByteBuffer;
+
+/// Decoder for {@code vortex.varbin} — variable-length binary / UTF-8 string arrays.
+///
+/// <p>Metadata: protobuf {@code VarBinMetadata} — {@code offsets_ptype PType} (tag 1).
+///
+/// <p>Buffer 0: concatenated raw bytes of all strings.
+/// Child slot 0: offsets array (length = rowCount + 1, dtype = offsets_ptype).
+///   {@code offsets[i]..offsets[i+1]} is the byte range of element {@code i} in the bytes buffer.
+/// Child slot 1 (optional): validity array — ignored for non-nullable columns.
+///
+/// <p>The returned {@code Array} exposes:
+/// <ul>
+///   <li>{@code buffer(0)} — the raw bytes segment</li>
+///   <li>{@code child(0)} — the offsets array (I32 or I64 primitives)</li>
+/// </ul>
+public final class VarBinCodec implements Codec {
+
+	@Override
+	public CodecId encodingId() {
+		return CodecId.VORTEX_VARBIN;
+	}
+
+	@Override
+	public EncodeResult encode(DType dtype, Object data) {
+		throw new UnsupportedOperationException("encode not supported by " + encodingId());
+	}
+
+	@Override
+	public Array decode(DecodeContext ctx) {
+		ByteBuffer rawMeta = ctx.metadata();
+		if (rawMeta == null) {
+			throw new IllegalStateException("vortex.varbin: missing metadata");
+		}
+		EncodingProtos.VarBinMetadata meta;
+		try {
+			meta = EncodingProtos.VarBinMetadata.parseFrom(rawMeta.duplicate());
+		} catch (InvalidProtocolBufferException e) {
+			throw new IllegalStateException("vortex.varbin: invalid metadata", e);
+		}
+
+		PType offsetsPtype = PType.values()[meta.getOffsetsPtype().getNumber()];
+		DType offsetsDtype = new DType.Primitive(offsetsPtype, false);
+		long n = ctx.rowCount();
+
+		// Offsets: n+1 elements; bytes: raw string data.
+		ArrayNode offsetsNode = ctx.node().children()[0];
+		DecodeContext offsetsCtx = new DecodeContext(
+				offsetsNode, offsetsDtype, n + 1,
+				ctx.segmentBuffers(), ctx.registry(), ctx.arena());
+		Array offsets = ctx.registry().decode(offsetsCtx);
+
+		MemorySegment bytes = ctx.buffer(0);
+
+		return new Array(ctx.dtype(), n,
+				new MemorySegment[]{bytes},
+				new Array[]{offsets},
+				ArrayStats.empty());
+	}
+}

core/src/main/proto/encodings.proto

@@ -50,3 +50,7 @@ message SequenceMetadata {
   vortex.scalar.ScalarValue base = 1;
   vortex.scalar.ScalarValue multiplier = 2;
 }
+
+message VarBinMetadata {
+  vortex.dtype.PType offsets_ptype = 1;
+}

core/src/main/resources/META-INF/services/io.github.dfa1.vortex.encoding.Codec

@@ -9,3 +9,4 @@ io.github.dfa1.vortex.encoding.SparseCodec
 io.github.dfa1.vortex.encoding.AlpCodec
 io.github.dfa1.vortex.encoding.RunEndCodec
 io.github.dfa1.vortex.encoding.ConstantCodec
+io.github.dfa1.vortex.encoding.VarBinCodec

performance/src/main/java/io/github/dfa1/vortex/performance/RustVsJavaReadBenchmark.java

@@ -183,6 +183,32 @@ public double jniReadClose() throws IOException {
 		return sum;
 	}
 
+	/// JNI read: project on "symbol" (short UTF-8 string, varbin), sum byte lengths.
+	@Benchmark
+	public long jniReadSymbol() throws IOException {
+		String uri = benchFile.toAbsolutePath().toUri().toString();
+		var opts = ScanOptions.builder()
+				.projection(Expression.select(new String[]{"symbol"}, Expression.root()))
+				.build();
+
+		long sum = 0L;
+		DataSource ds = DataSource.open(SESSION, uri);
+		Scan scan = ds.scan(opts);
+		while (scan.hasNext()) {
+			Partition partition = scan.next();
+			try (ArrowReader reader = partition.scanArrow(allocator)) {
+				while (reader.loadNextBatch()) {
+					VectorSchemaRoot root = reader.getVectorSchemaRoot();
+					VarCharVector symbolVec = (VarCharVector) root.getVector("symbol");
+					for (int i = 0; i < root.getRowCount(); i++) {
+						sum += symbolVec.getObject(i).getBytes().length;
+					}
+				}
+			}
+		}
+		return sum;
+	}
+
 	// ── JNI file generation ───────────────────────────────────────────────────
 
 	/// Java read: project on "volume", sum all values.
@@ -225,6 +251,31 @@ public double javaReadClose() throws IOException {
 		return sum;
 	}
 
+	/// Java read: project on "symbol" (short UTF-8 string, varbin), sum byte lengths.
+	@Benchmark
+	public long javaReadSymbol() throws IOException {
+		long sum = 0L;
+		try (VortexReader vf = VortexReader.open(benchFile, registry)) {
+			var iter = vf.scan(io.github.dfa1.vortex.scan.ScanOptions.columns("symbol"));
+			while (iter.hasNext()) {
+				ScanResult r = iter.next();
+				Array arr = r.columns().get("symbol");
+				// buffer(0) = raw bytes; child(0) = offsets
+				MemorySegment bytes = arr.buffer(0);
+				Array offsets = arr.child(0);
+				MemorySegment offsetSeg = offsets.buffer(0);
+				var offsetLayout = ValueLayout.JAVA_INT_UNALIGNED;
+				long n = arr.length();
+				for (long i = 0; i < n; i++) {
+					int start = offsetSeg.getAtIndex(offsetLayout, i);
+					int end = offsetSeg.getAtIndex(offsetLayout, i + 1);
+					sum += end - start;
+				}
+			}
+		}
+		return sum;
+	}
+
 	private void writeJni(Path path) throws IOException {
 		String uri = path.toAbsolutePath().toUri().toString();
 		try (dev.vortex.api.VortexWriter writer = dev.vortex.api.VortexWriter.create(