diff --git a/code/libraries/coded-sequence/java/nu/marginalia/sequence/slop/GammaCodedSequenceColumn.java b/code/libraries/coded-sequence/java/nu/marginalia/sequence/slop/GammaCodedSequenceColumn.java index a141e6a3..e27586de 100644 --- a/code/libraries/coded-sequence/java/nu/marginalia/sequence/slop/GammaCodedSequenceColumn.java +++ b/code/libraries/coded-sequence/java/nu/marginalia/sequence/slop/GammaCodedSequenceColumn.java @@ -22,20 +22,20 @@ public class GammaCodedSequenceColumn { public static ColumnType TYPE = ColumnType.register("s8[]+gcs", ByteOrder.nativeOrder(), GammaCodedSequenceColumn::open, GammaCodedSequenceColumn::create); - public static GammaCodedSequenceReader open(Path path, ColumnDesc name) throws IOException { - return new Reader( - Storage.reader(path, name, false), // note we must never pass aligned=true here, as the data is not guaranteed alignment - VarintColumn.open(path, name.createSupplementaryColumn(ColumnFunction.DATA_LEN, + public static GammaCodedSequenceReader open(Path path, ColumnDesc columnDesc) throws IOException { + return new Reader(columnDesc, + Storage.reader(path, columnDesc, false), // note we must never pass aligned=true here, as the data is not guaranteed alignment + VarintColumn.open(path, columnDesc.createSupplementaryColumn(ColumnFunction.DATA_LEN, ColumnType.VARINT_LE, StorageType.PLAIN) ) ); } - public static GammaCodedSequenceWriter create(Path path, ColumnDesc name) throws IOException { - return new Writer( - Storage.writer(path, name), - VarintColumn.create(path, name.createSupplementaryColumn(ColumnFunction.DATA_LEN, + public static GammaCodedSequenceWriter create(Path path, ColumnDesc columnDesc) throws IOException { + return new Writer(columnDesc, + Storage.writer(path, columnDesc), + VarintColumn.create(path, columnDesc.createSupplementaryColumn(ColumnFunction.DATA_LEN, ColumnType.VARINT_LE, StorageType.PLAIN) ) @@ -44,16 +44,23 @@ public class GammaCodedSequenceColumn { private static class Writer implements GammaCodedSequenceWriter { private final VarintColumnWriter indexWriter; + private final ColumnDesc columnDesc; private final StorageWriter storage; - public Writer(StorageWriter storage, + public Writer(ColumnDesc columnDesc, + StorageWriter storage, VarintColumnWriter indexWriter) { + this.columnDesc = columnDesc; this.storage = storage; this.indexWriter = indexWriter; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } @Override public void put(GammaCodedSequence sequence) throws IOException { @@ -76,13 +83,20 @@ public class GammaCodedSequenceColumn { private static class Reader implements GammaCodedSequenceReader { private final VarintColumnReader indexReader; + private final ColumnDesc columnDesc; private final StorageReader storage; - public Reader(StorageReader reader, VarintColumnReader indexReader) throws IOException { + public Reader(ColumnDesc columnDesc, StorageReader reader, VarintColumnReader indexReader) throws IOException { + this.columnDesc = columnDesc; this.storage = reader; this.indexReader = indexReader; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + @Override public void skip(long positions) throws IOException { for (int i = 0; i < positions; i++) { diff --git a/code/libraries/slop/java/nu/marginalia/slop/column/ColumnReader.java b/code/libraries/slop/java/nu/marginalia/slop/column/ColumnReader.java index 2116197d..f870c56c 100644 --- a/code/libraries/slop/java/nu/marginalia/slop/column/ColumnReader.java +++ b/code/libraries/slop/java/nu/marginalia/slop/column/ColumnReader.java @@ -1,8 +1,13 @@ package nu.marginalia.slop.column; +import nu.marginalia.slop.desc.ColumnDesc; + import java.io.IOException; public interface ColumnReader { + + ColumnDesc columnDesc(); + long position() throws IOException; void skip(long positions) throws IOException; diff --git a/code/libraries/slop/java/nu/marginalia/slop/column/ColumnWriter.java b/code/libraries/slop/java/nu/marginalia/slop/column/ColumnWriter.java index 661a4021..d2c73f95 100644 --- a/code/libraries/slop/java/nu/marginalia/slop/column/ColumnWriter.java +++ b/code/libraries/slop/java/nu/marginalia/slop/column/ColumnWriter.java @@ -1,8 +1,12 @@ package nu.marginalia.slop.column; +import nu.marginalia.slop.desc.ColumnDesc; + import java.io.IOException; public interface ColumnWriter { + ColumnDesc columnDesc(); + /** Return the current record index in the column */ long position(); diff --git a/code/libraries/slop/java/nu/marginalia/slop/column/array/ByteArrayColumn.java b/code/libraries/slop/java/nu/marginalia/slop/column/array/ByteArrayColumn.java index f641de3f..157efa84 100644 --- a/code/libraries/slop/java/nu/marginalia/slop/column/array/ByteArrayColumn.java +++ b/code/libraries/slop/java/nu/marginalia/slop/column/array/ByteArrayColumn.java @@ -15,22 +15,24 @@ import java.nio.file.Path; public class ByteArrayColumn { - public static ByteArrayColumnReader open(Path path, ColumnDesc name) throws IOException { + public static ByteArrayColumnReader open(Path path, ColumnDesc columnDesc) throws IOException { return new Reader( - Storage.reader(path, name, true), + columnDesc, + Storage.reader(path, columnDesc, true), VarintColumn.open(path, - name.createSupplementaryColumn(name.function().lengthsTable(), + columnDesc.createSupplementaryColumn(columnDesc.function().lengthsTable(), ColumnType.VARINT_LE, StorageType.PLAIN) ) ); } - public static ByteArrayColumnWriter create(Path path, ColumnDesc name) throws IOException { + public static ByteArrayColumnWriter create(Path path, ColumnDesc columnDesc) throws IOException { return new Writer( - Storage.writer(path, name), + columnDesc, + Storage.writer(path, columnDesc), VarintColumn.create(path, - name.createSupplementaryColumn(name.function().lengthsTable(), + columnDesc.createSupplementaryColumn(columnDesc.function().lengthsTable(), ColumnType.VARINT_LE, StorageType.PLAIN) ) @@ -38,16 +40,23 @@ public class ByteArrayColumn { } private static class Writer implements ByteArrayColumnWriter { + private final ColumnDesc columnDesc; private final StorageWriter storage; private final VarintColumnWriter lengthsWriter; private long position = 0; - public Writer(StorageWriter storage, VarintColumnWriter lengthsWriter) throws IOException { + public Writer(ColumnDesc columnDesc, StorageWriter storage, VarintColumnWriter lengthsWriter) throws IOException { + this.columnDesc = columnDesc; this.storage = storage; this.lengthsWriter = lengthsWriter; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public void put(byte[] value) throws IOException { position ++; storage.putBytes(value); @@ -65,14 +74,21 @@ public class ByteArrayColumn { } private static class Reader implements ByteArrayColumnReader { + private final ColumnDesc columnDesc; private final StorageReader storage; private final VarintColumnReader lengthsReader; - public Reader(StorageReader storage, VarintColumnReader lengthsReader) throws IOException { + public Reader(ColumnDesc columnDesc, StorageReader storage, VarintColumnReader lengthsReader) throws IOException { + this.columnDesc = columnDesc; this.storage = storage; this.lengthsReader = lengthsReader; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public byte[] get() throws IOException { int length = (int) lengthsReader.get(); byte[] ret = new byte[length]; diff --git a/code/libraries/slop/java/nu/marginalia/slop/column/array/IntArrayColumn.java b/code/libraries/slop/java/nu/marginalia/slop/column/array/IntArrayColumn.java index c5a1421c..8eba4f56 100644 --- a/code/libraries/slop/java/nu/marginalia/slop/column/array/IntArrayColumn.java +++ b/code/libraries/slop/java/nu/marginalia/slop/column/array/IntArrayColumn.java @@ -15,18 +15,20 @@ import java.nio.file.Path; public class IntArrayColumn { - public static IntArrayColumnReader open(Path path, ColumnDesc name) throws IOException { - return new Reader(Storage.reader(path, name, true), - VarintColumn.open(path, name.createSupplementaryColumn(name.function().lengthsTable(), + public static IntArrayColumnReader open(Path path, ColumnDesc columnDesc) throws IOException { + return new Reader(columnDesc, + Storage.reader(path, columnDesc, true), + VarintColumn.open(path, columnDesc.createSupplementaryColumn(columnDesc.function().lengthsTable(), ColumnType.VARINT_LE, StorageType.PLAIN) ) ); } - public static IntArrayColumnWriter create(Path path, ColumnDesc name) throws IOException { - return new Writer(Storage.writer(path, name), - VarintColumn.create(path, name.createSupplementaryColumn(name.function().lengthsTable(), + public static IntArrayColumnWriter create(Path path, ColumnDesc columnDesc) throws IOException { + return new Writer(columnDesc, + Storage.writer(path, columnDesc), + VarintColumn.create(path, columnDesc.createSupplementaryColumn(columnDesc.function().lengthsTable(), ColumnType.VARINT_LE, StorageType.PLAIN) ) @@ -34,14 +36,21 @@ public class IntArrayColumn { } private static class Writer implements IntArrayColumnWriter { + private final ColumnDesc columnDesc; private final StorageWriter storage; private final VarintColumnWriter lengthsWriter; - public Writer(StorageWriter storage, VarintColumnWriter lengthsWriter) throws IOException { + public Writer(ColumnDesc columnDesc, StorageWriter storage, VarintColumnWriter lengthsWriter) throws IOException { + this.columnDesc = columnDesc; this.storage = storage; this.lengthsWriter = lengthsWriter; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public void put(int[] value) throws IOException { storage.putInts(value); lengthsWriter.put(value.length); @@ -58,14 +67,21 @@ public class IntArrayColumn { } private static class Reader implements IntArrayColumnReader { + private final ColumnDesc columnDesc; private final StorageReader storage; private final VarintColumnReader lengthsReader; - public Reader(StorageReader storage, VarintColumnReader lengthsReader) { + public Reader(ColumnDesc columnDesc, StorageReader storage, VarintColumnReader lengthsReader) { + this.columnDesc = columnDesc; this.storage = storage; this.lengthsReader = lengthsReader; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public int[] get() throws IOException { int length = (int) lengthsReader.get(); int[] ret = new int[length]; diff --git a/code/libraries/slop/java/nu/marginalia/slop/column/array/LongArrayColumn.java b/code/libraries/slop/java/nu/marginalia/slop/column/array/LongArrayColumn.java index b805a085..4773f31c 100644 --- a/code/libraries/slop/java/nu/marginalia/slop/column/array/LongArrayColumn.java +++ b/code/libraries/slop/java/nu/marginalia/slop/column/array/LongArrayColumn.java @@ -15,18 +15,22 @@ import java.nio.file.Path; public class LongArrayColumn { - public static LongArrayColumnReader open(Path path, ColumnDesc name) throws IOException { - return new LongArrayColumn.Reader(Storage.reader(path, name, true), - VarintColumn.open(path, name.createSupplementaryColumn(name.function().lengthsTable(), + public static LongArrayColumnReader open(Path path, ColumnDesc columnDesc) throws IOException { + return new LongArrayColumn.Reader( + columnDesc, + Storage.reader(path, columnDesc, true), + VarintColumn.open(path, columnDesc.createSupplementaryColumn(columnDesc.function().lengthsTable(), ColumnType.VARINT_LE, StorageType.PLAIN) ) ); } - public static LongArrayColumnWriter create(Path path, ColumnDesc name) throws IOException { - return new LongArrayColumn.Writer(Storage.writer(path, name), - VarintColumn.create(path, name.createSupplementaryColumn(name.function().lengthsTable(), + public static LongArrayColumnWriter create(Path path, ColumnDesc columnDesc) throws IOException { + return new LongArrayColumn.Writer( + columnDesc, + Storage.writer(path, columnDesc), + VarintColumn.create(path, columnDesc.createSupplementaryColumn(columnDesc.function().lengthsTable(), ColumnType.VARINT_LE, StorageType.PLAIN) ) @@ -34,14 +38,21 @@ public class LongArrayColumn { } private static class Writer implements LongArrayColumnWriter { + private final ColumnDesc columnDesc; private final StorageWriter storage; private final VarintColumnWriter lengthsWriter; - public Writer(StorageWriter storage, VarintColumnWriter lengthsWriter) throws IOException { + public Writer(ColumnDesc columnDesc, StorageWriter storage, VarintColumnWriter lengthsWriter) throws IOException { + this.columnDesc = columnDesc; this.storage = storage; this.lengthsWriter = lengthsWriter; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public void put(long[] value) throws IOException { storage.putLongs(value); lengthsWriter.put(value.length); @@ -58,14 +69,21 @@ public class LongArrayColumn { } private static class Reader implements LongArrayColumnReader { + private final ColumnDesc columnDesc; private final StorageReader storage; private final VarintColumnReader lengthsReader; - public Reader(StorageReader storage, VarintColumnReader lengthsReader) { + public Reader(ColumnDesc columnDesc, StorageReader storage, VarintColumnReader lengthsReader) { + this.columnDesc = columnDesc; this.storage = storage; this.lengthsReader = lengthsReader; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public long[] get() throws IOException { int length = (int) lengthsReader.get(); long[] ret = new long[length]; diff --git a/code/libraries/slop/java/nu/marginalia/slop/column/dynamic/CustomBinaryColumn.java b/code/libraries/slop/java/nu/marginalia/slop/column/dynamic/CustomBinaryColumn.java index 910a02a2..9d3dd189 100644 --- a/code/libraries/slop/java/nu/marginalia/slop/column/dynamic/CustomBinaryColumn.java +++ b/code/libraries/slop/java/nu/marginalia/slop/column/dynamic/CustomBinaryColumn.java @@ -13,20 +13,22 @@ import java.nio.file.Path; public class CustomBinaryColumn { - public static CustomBinaryColumnReader open(Path path, ColumnDesc name) throws IOException { + public static CustomBinaryColumnReader open(Path path, ColumnDesc columnDesc) throws IOException { return new Reader( - Storage.reader(path, name, false), // note we must never pass aligned=true here, as the data is not guaranteed alignment - VarintColumn.open(path, name.createSupplementaryColumn(ColumnFunction.DATA_LEN, + columnDesc, + Storage.reader(path, columnDesc, false), // note we must never pass aligned=true here, as the data is not guaranteed alignment + VarintColumn.open(path, columnDesc.createSupplementaryColumn(ColumnFunction.DATA_LEN, ColumnType.VARINT_LE, StorageType.PLAIN) ) ); } - public static CustomBinaryColumnWriter create(Path path, ColumnDesc name) throws IOException { + public static CustomBinaryColumnWriter create(Path path, ColumnDesc columnDesc) throws IOException { return new Writer( - Storage.writer(path, name), - VarintColumn.create(path, name.createSupplementaryColumn(ColumnFunction.DATA_LEN, + columnDesc, + Storage.writer(path, columnDesc), + VarintColumn.create(path, columnDesc.createSupplementaryColumn(ColumnFunction.DATA_LEN, ColumnType.VARINT_LE, StorageType.PLAIN) ) @@ -35,16 +37,24 @@ public class CustomBinaryColumn { private static class Writer implements CustomBinaryColumnWriter { private final VarintColumnWriter indexWriter; + private final ColumnDesc columnDesc; private final StorageWriter storage; - public Writer(StorageWriter storage, + public Writer(ColumnDesc columnDesc, + StorageWriter storage, VarintColumnWriter indexWriter) { + this.columnDesc = columnDesc; this.storage = storage; - this.indexWriter = indexWriter; } + + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + @Override public RecordWriter next() throws IOException { return new RecordWriter() { @@ -74,13 +84,20 @@ public class CustomBinaryColumn { private static class Reader implements CustomBinaryColumnReader { private final VarintColumnReader indexReader; + private final ColumnDesc columnDesc; private final StorageReader storage; - public Reader(StorageReader reader, VarintColumnReader indexReader) throws IOException { + public Reader(ColumnDesc columnDesc, StorageReader reader, VarintColumnReader indexReader) throws IOException { + this.columnDesc = columnDesc; this.storage = reader; this.indexReader = indexReader; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + @Override public void skip(long positions) throws IOException { for (int i = 0; i < positions; i++) { diff --git a/code/libraries/slop/java/nu/marginalia/slop/column/dynamic/VarintColumn.java b/code/libraries/slop/java/nu/marginalia/slop/column/dynamic/VarintColumn.java index aee6409b..8d28f29c 100644 --- a/code/libraries/slop/java/nu/marginalia/slop/column/dynamic/VarintColumn.java +++ b/code/libraries/slop/java/nu/marginalia/slop/column/dynamic/VarintColumn.java @@ -11,22 +11,29 @@ import java.nio.file.Path; public class VarintColumn { public static VarintColumnReader open(Path path, ColumnDesc columnDesc) throws IOException { - return new Reader(Storage.reader(path, columnDesc, true)); + return new Reader(columnDesc, Storage.reader(path, columnDesc, true)); } public static VarintColumnWriter create(Path path, ColumnDesc columnDesc) throws IOException { - return new Writer(Storage.writer(path, columnDesc)); + return new Writer(columnDesc, Storage.writer(path, columnDesc)); } private static class Writer implements VarintColumnWriter { + private final ColumnDesc columnDesc; private final StorageWriter writer; private long position = 0; - public Writer(StorageWriter writer) throws IOException { + public Writer(ColumnDesc columnDesc, StorageWriter writer) throws IOException { + this.columnDesc = columnDesc; this.writer = writer; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public void put(long value) throws IOException { position++; @@ -53,14 +60,21 @@ public class VarintColumn { } private static class Reader implements VarintColumnReader { + private final ColumnDesc columnDesc; private final StorageReader reader; private long position = 0; - public Reader(StorageReader reader) throws IOException { + public Reader(ColumnDesc columnDesc, StorageReader reader) throws IOException { + this.columnDesc = columnDesc; this.reader = reader; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public long get() throws IOException { long value = 0; int shift = 0; diff --git a/code/libraries/slop/java/nu/marginalia/slop/column/primitive/ByteColumn.java b/code/libraries/slop/java/nu/marginalia/slop/column/primitive/ByteColumn.java index 017f611e..00134bf2 100644 --- a/code/libraries/slop/java/nu/marginalia/slop/column/primitive/ByteColumn.java +++ b/code/libraries/slop/java/nu/marginalia/slop/column/primitive/ByteColumn.java @@ -11,21 +11,28 @@ import java.nio.file.Path; public class ByteColumn { public static ByteColumnReader open(Path path, ColumnDesc columnDesc) throws IOException { - return new Reader(Storage.reader(path, columnDesc, true)); + return new Reader(columnDesc, Storage.reader(path, columnDesc, true)); } public static ByteColumnWriter create(Path path, ColumnDesc columnDesc) throws IOException { - return new Writer(Storage.writer(path, columnDesc)); + return new Writer(columnDesc, Storage.writer(path, columnDesc)); } private static class Writer implements ByteColumnWriter { + private final ColumnDesc columnDesc; private final StorageWriter storage; private long position = 0; - public Writer(StorageWriter storageWriter) throws IOException { + public Writer(ColumnDesc columnDesc, StorageWriter storageWriter) throws IOException { + this.columnDesc = columnDesc; this.storage = storageWriter; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public void put(byte value) throws IOException { storage.putByte(value); position++; @@ -41,9 +48,11 @@ public class ByteColumn { } private static class Reader implements ByteColumnReader { + private final ColumnDesc columnDesc; private final StorageReader storage; - public Reader(StorageReader storage) throws IOException { + public Reader(ColumnDesc columnDesc, StorageReader storage) throws IOException { + this.columnDesc = columnDesc; this.storage = storage; } @@ -51,6 +60,11 @@ public class ByteColumn { return storage.getByte(); } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + @Override public long position() throws IOException { return storage.position(); diff --git a/code/libraries/slop/java/nu/marginalia/slop/column/primitive/CharColumn.java b/code/libraries/slop/java/nu/marginalia/slop/column/primitive/CharColumn.java index 56a470aa..74918d01 100644 --- a/code/libraries/slop/java/nu/marginalia/slop/column/primitive/CharColumn.java +++ b/code/libraries/slop/java/nu/marginalia/slop/column/primitive/CharColumn.java @@ -11,28 +11,35 @@ import java.nio.file.Path; public class CharColumn { public static CharColumnReader open(Path path, ColumnDesc columnDesc) throws IOException { - return new Reader(Storage.reader(path, columnDesc, true)); + return new Reader(columnDesc, Storage.reader(path, columnDesc, true)); } public static CharColumnWriter create(Path path, ColumnDesc columnDesc) throws IOException { - return new Writer(Storage.writer(path, columnDesc)); + return new Writer(columnDesc, Storage.writer(path, columnDesc)); } private static class Writer implements CharColumnWriter { + private final ColumnDesc columnDesc; private final StorageWriter storage; private long position = 0; - public Writer(StorageWriter storageWriter) throws IOException { + public Writer(ColumnDesc columnDesc, StorageWriter storageWriter) throws IOException { + this.columnDesc = columnDesc; this.storage = storageWriter; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public void put(char value) throws IOException { storage.putChar(value); position++; } public long position() { - return position / Character.BYTES; + return position; } public void close() throws IOException { @@ -41,9 +48,11 @@ public class CharColumn { } private static class Reader implements CharColumnReader { + private final ColumnDesc columnDesc; private final StorageReader storage; - public Reader(StorageReader storage) throws IOException { + public Reader(ColumnDesc columnDesc, StorageReader storage) throws IOException { + this.columnDesc = columnDesc; this.storage = storage; } @@ -51,9 +60,14 @@ public class CharColumn { return storage.getChar(); } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + @Override public long position() throws IOException { - return storage.position(); + return storage.position() / Character.BYTES; } @Override diff --git a/code/libraries/slop/java/nu/marginalia/slop/column/primitive/DoubleColumn.java b/code/libraries/slop/java/nu/marginalia/slop/column/primitive/DoubleColumn.java index 0a9635de..bcfcaebe 100644 --- a/code/libraries/slop/java/nu/marginalia/slop/column/primitive/DoubleColumn.java +++ b/code/libraries/slop/java/nu/marginalia/slop/column/primitive/DoubleColumn.java @@ -11,28 +11,35 @@ import java.nio.file.Path; public class DoubleColumn { public static DoubleColumnReader open(Path path, ColumnDesc columnDesc) throws IOException { - return new Reader(Storage.reader(path, columnDesc, true)); + return new Reader(columnDesc, Storage.reader(path, columnDesc, true)); } public static DoubleColumnWriter create(Path path, ColumnDesc columnDesc) throws IOException { - return new Writer(Storage.writer(path, columnDesc)); + return new Writer(columnDesc, Storage.writer(path, columnDesc)); } private static class Writer implements DoubleColumnWriter { + private final ColumnDesc columnDesc; private final StorageWriter storage; private long position = 0; - public Writer(StorageWriter storageWriter) throws IOException { + public Writer(ColumnDesc columnDesc, StorageWriter storageWriter) throws IOException { + this.columnDesc = columnDesc; this.storage = storageWriter; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public void put(double value) throws IOException { storage.putDouble(value); position++; } public long position() { - return position / Double.BYTES; + return position; } public void close() throws IOException { @@ -41,19 +48,26 @@ public class DoubleColumn { } private static class Reader implements DoubleColumnReader { + private final ColumnDesc columnDesc; private final StorageReader storage; - public Reader(StorageReader storage) throws IOException { + public Reader(ColumnDesc columnDesc, StorageReader storage) throws IOException { + this.columnDesc = columnDesc; this.storage = storage; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public double get() throws IOException { return storage.getDouble(); } @Override public long position() throws IOException { - return storage.position(); + return storage.position() / Double.BYTES; } @Override diff --git a/code/libraries/slop/java/nu/marginalia/slop/column/primitive/FloatColumn.java b/code/libraries/slop/java/nu/marginalia/slop/column/primitive/FloatColumn.java index 8e689cf4..369ae98d 100644 --- a/code/libraries/slop/java/nu/marginalia/slop/column/primitive/FloatColumn.java +++ b/code/libraries/slop/java/nu/marginalia/slop/column/primitive/FloatColumn.java @@ -11,22 +11,29 @@ import java.nio.file.Path; public class FloatColumn { public static FloatColumnReader open(Path path, ColumnDesc columnDesc) throws IOException { - return new Reader(Storage.reader(path, columnDesc, true)); + return new Reader(columnDesc, Storage.reader(path, columnDesc, true)); } public static FloatColumnWriter create(Path path, ColumnDesc columnDesc) throws IOException { - return new Writer(Storage.writer(path, columnDesc)); + return new Writer(columnDesc, Storage.writer(path, columnDesc)); } private static class Writer implements FloatColumnWriter { + private final ColumnDesc columnDesc; private final StorageWriter storage; private long position = 0; - public Writer(StorageWriter storageWriter) throws IOException { + public Writer(ColumnDesc columnDesc, StorageWriter storageWriter) throws IOException { + this.columnDesc = columnDesc; this.storage = storageWriter; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public void put(float value) throws IOException { storage.putFloat(value); position++; @@ -42,12 +49,19 @@ public class FloatColumn { } private static class Reader implements FloatColumnReader { + private final ColumnDesc columnDesc; private final StorageReader storage; - public Reader(StorageReader storage) throws IOException { + public Reader(ColumnDesc columnDesc, StorageReader storage) throws IOException { + this.columnDesc = columnDesc; this.storage = storage; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public float get() throws IOException { return storage.getFloat(); } diff --git a/code/libraries/slop/java/nu/marginalia/slop/column/primitive/IntColumn.java b/code/libraries/slop/java/nu/marginalia/slop/column/primitive/IntColumn.java index f4c25235..9b1d0103 100644 --- a/code/libraries/slop/java/nu/marginalia/slop/column/primitive/IntColumn.java +++ b/code/libraries/slop/java/nu/marginalia/slop/column/primitive/IntColumn.java @@ -11,21 +11,28 @@ import java.nio.file.Path; public class IntColumn { public static IntColumnReader open(Path path, ColumnDesc columnDesc) throws IOException { - return new Reader(Storage.reader(path, columnDesc, true)); + return new Reader(columnDesc, Storage.reader(path, columnDesc, true)); } public static IntColumnWriter create(Path path, ColumnDesc columnDesc) throws IOException { - return new Writer(Storage.writer(path, columnDesc)); + return new Writer(columnDesc, Storage.writer(path, columnDesc)); } private static class Writer implements IntColumnWriter { + private final ColumnDesc columnDesc; private final StorageWriter storage; private long position = 0; - public Writer(StorageWriter storageWriter) throws IOException { + public Writer(ColumnDesc columnDesc, StorageWriter storageWriter) throws IOException { + this.columnDesc = columnDesc; this.storage = storageWriter; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public void put(int[] values) throws IOException { for (int value : values) { storage.putInt(value); @@ -39,7 +46,7 @@ public class IntColumn { } public long position() { - return position / Integer.BYTES; + return position; } public void close() throws IOException { @@ -48,12 +55,19 @@ public class IntColumn { } private static class Reader implements IntColumnReader { + private final ColumnDesc columnDesc; private final StorageReader storage; - public Reader(StorageReader storage) throws IOException { + public Reader(ColumnDesc columnDesc, StorageReader storage) throws IOException { + this.columnDesc = columnDesc; this.storage = storage; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public int get() throws IOException { return storage.getInt(); } diff --git a/code/libraries/slop/java/nu/marginalia/slop/column/primitive/LongColumn.java b/code/libraries/slop/java/nu/marginalia/slop/column/primitive/LongColumn.java index 88289cd4..e0659f6f 100644 --- a/code/libraries/slop/java/nu/marginalia/slop/column/primitive/LongColumn.java +++ b/code/libraries/slop/java/nu/marginalia/slop/column/primitive/LongColumn.java @@ -11,21 +11,28 @@ import java.nio.file.Path; public class LongColumn { public static LongColumnReader open(Path path, ColumnDesc columnDesc) throws IOException { - return new Reader(Storage.reader(path, columnDesc, true)); + return new Reader(columnDesc, Storage.reader(path, columnDesc, true)); } public static LongColumnWriter create(Path path, ColumnDesc columnDesc) throws IOException { - return new Writer(Storage.writer(path, columnDesc)); + return new Writer(columnDesc, Storage.writer(path, columnDesc)); } private static class Writer implements LongColumnWriter { + private final ColumnDesc columnDesc; private final StorageWriter storage; private long position = 0; - public Writer(StorageWriter storageWriter) { + public Writer(ColumnDesc columnDesc, StorageWriter storageWriter) { + this.columnDesc = columnDesc; this.storage = storageWriter; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public void put(long value) throws IOException { storage.putLong(value); position++; @@ -41,12 +48,19 @@ public class LongColumn { } private static class Reader implements LongColumnReader { + private final ColumnDesc columnDesc; private final StorageReader storage; - public Reader(StorageReader storage) throws IOException { + public Reader(ColumnDesc columnDesc, StorageReader storage) throws IOException { + this.columnDesc = columnDesc; this.storage = storage; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public long get() throws IOException { return storage.getLong(); } diff --git a/code/libraries/slop/java/nu/marginalia/slop/column/string/EnumColumn.java b/code/libraries/slop/java/nu/marginalia/slop/column/string/EnumColumn.java index b452f0de..c1f69c8a 100644 --- a/code/libraries/slop/java/nu/marginalia/slop/column/string/EnumColumn.java +++ b/code/libraries/slop/java/nu/marginalia/slop/column/string/EnumColumn.java @@ -16,16 +16,17 @@ import java.util.List; public class EnumColumn { - public static StringColumnReader open(Path path, ColumnDesc name) throws IOException { + public static StringColumnReader open(Path path, ColumnDesc columnDesc) throws IOException { return new Reader( + columnDesc, StringColumn.open(path, - name.createSupplementaryColumn( + columnDesc.createSupplementaryColumn( ColumnFunction.DICT, ColumnType.TXTSTRING, StorageType.PLAIN) ), VarintColumn.open(path, - name.createSupplementaryColumn( + columnDesc.createSupplementaryColumn( ColumnFunction.DATA, ColumnType.ENUM_LE, StorageType.PLAIN @@ -34,26 +35,34 @@ public class EnumColumn { ); } - public static StringColumnWriter create(Path path, ColumnDesc name) throws IOException { - return new Writer( - StringColumn.create(path, name.createSupplementaryColumn(ColumnFunction.DICT, ColumnType.TXTSTRING, StorageType.PLAIN)), - VarintColumn.create(path, name.createSupplementaryColumn(ColumnFunction.DATA, ColumnType.ENUM_LE, StorageType.PLAIN)) + public static StringColumnWriter create(Path path, ColumnDesc columnDesc) throws IOException { + return new Writer(columnDesc, + StringColumn.create(path, columnDesc.createSupplementaryColumn(ColumnFunction.DICT, ColumnType.TXTSTRING, StorageType.PLAIN)), + VarintColumn.create(path, columnDesc.createSupplementaryColumn(ColumnFunction.DATA, ColumnType.ENUM_LE, StorageType.PLAIN)) ); } private static class Writer implements StringColumnWriter { + private final ColumnDesc columnDesc; private final StringColumnWriter dicionaryColumn; private final LongColumnWriter dataColumn; private final HashMap dictionary = new HashMap<>(); - public Writer(StringColumnWriter dicionaryColumn, + public Writer(ColumnDesc columnDesc, + StringColumnWriter dicionaryColumn, LongColumnWriter dataColumn) throws IOException { + this.columnDesc = columnDesc; this.dicionaryColumn = dicionaryColumn; this.dataColumn = dataColumn; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public void put(String value) throws IOException { Integer index = dictionary.get(value); if (index == null) { @@ -75,12 +84,15 @@ public class EnumColumn { } private static class Reader implements StringColumnReader { + private final ColumnDesc columnDesc; private final LongColumnReader dataColumn; private final List dictionary = new ArrayList<>(); - public Reader(StringColumnReader dicionaryColumn, + public Reader(ColumnDesc columnDesc, + StringColumnReader dicionaryColumn, LongColumnReader dataColumn) throws IOException { + this.columnDesc = columnDesc; this.dataColumn = dataColumn; for (int i = 0; dicionaryColumn.hasRemaining(); i++) { dictionary.add(dicionaryColumn.get()); @@ -88,6 +100,11 @@ public class EnumColumn { dicionaryColumn.close(); } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public String get() throws IOException { int index = (int) dataColumn.get(); return dictionary.get(index); diff --git a/code/libraries/slop/java/nu/marginalia/slop/column/string/StringColumn.java b/code/libraries/slop/java/nu/marginalia/slop/column/string/StringColumn.java index a41aa4e0..0dd30f56 100644 --- a/code/libraries/slop/java/nu/marginalia/slop/column/string/StringColumn.java +++ b/code/libraries/slop/java/nu/marginalia/slop/column/string/StringColumn.java @@ -14,35 +14,42 @@ import java.nio.file.Path; public class StringColumn { - public static StringColumnReader open(Path path, ColumnDesc name) throws IOException { - if (name.type().equals(ColumnType.STRING)) { - return new ArrayReader(ByteArrayColumn.open(path, name)); - } else if (name.type().equals(ColumnType.CSTRING)) { - return new CStringReader(Storage.reader(path, name, true)); - } else if (name.type().equals(ColumnType.TXTSTRING)) { - return new TxtStringReader(Storage.reader(path, name, true)); + public static StringColumnReader open(Path path, ColumnDesc columnDesc) throws IOException { + if (columnDesc.type().equals(ColumnType.STRING)) { + return new ArrayReader(columnDesc, ByteArrayColumn.open(path, columnDesc)); + } else if (columnDesc.type().equals(ColumnType.CSTRING)) { + return new CStringReader(columnDesc, Storage.reader(path, columnDesc, true)); + } else if (columnDesc.type().equals(ColumnType.TXTSTRING)) { + return new TxtStringReader(columnDesc, Storage.reader(path, columnDesc, true)); } - throw new IllegalArgumentException("Unsupported column type: " + name.type()); + throw new IllegalArgumentException("Unsupported column type: " + columnDesc.type()); } - public static StringColumnWriter create(Path path, ColumnDesc name) throws IOException { - if (name.type().equals(ColumnType.STRING)) { - return new ArrayWriter(ByteArrayColumn.create(path, name)); - } else if (name.type().equals(ColumnType.CSTRING)) { - return new CStringWriter(Storage.writer(path, name)); - } else if (name.type().equals(ColumnType.TXTSTRING)) { - return new TxtStringWriter(Storage.writer(path, name)); + public static StringColumnWriter create(Path path, ColumnDesc columnDesc) throws IOException { + if (columnDesc.type().equals(ColumnType.STRING)) { + return new ArrayWriter(columnDesc, ByteArrayColumn.create(path, columnDesc)); + } else if (columnDesc.type().equals(ColumnType.CSTRING)) { + return new CStringWriter(columnDesc, Storage.writer(path, columnDesc)); + } else if (columnDesc.type().equals(ColumnType.TXTSTRING)) { + return new TxtStringWriter(columnDesc, Storage.writer(path, columnDesc)); } - throw new IllegalArgumentException("Unsupported column type: " + name.type()); + throw new IllegalArgumentException("Unsupported column type: " + columnDesc.type()); } private static class ArrayWriter implements StringColumnWriter { + private final ColumnDesc columnDesc; private final ByteArrayColumnWriter backingColumn; - public ArrayWriter(ByteArrayColumnWriter backingColumn) throws IOException { + public ArrayWriter(ColumnDesc columnDesc, ByteArrayColumnWriter backingColumn) throws IOException { + this.columnDesc = columnDesc; this.backingColumn = backingColumn; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public void put(String value) throws IOException { if (null == value) { value = ""; @@ -61,12 +68,19 @@ public class StringColumn { } private static class ArrayReader implements StringColumnReader { + private final ColumnDesc columnDesc; private final ByteArrayColumnReader backingColumn; - public ArrayReader(ByteArrayColumnReader backingColumn) throws IOException { + public ArrayReader(ColumnDesc columnDesc, ByteArrayColumnReader backingColumn) throws IOException { + this.columnDesc = columnDesc; this.backingColumn = backingColumn; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public String get() throws IOException { return new String(backingColumn.get()); } @@ -94,14 +108,21 @@ public class StringColumn { private static class CStringWriter implements StringColumnWriter { + private final ColumnDesc columnDesc; private final StorageWriter storageWriter; private long position = 0; - public CStringWriter(StorageWriter storageWriter) throws IOException { + public CStringWriter(ColumnDesc columnDesc, StorageWriter storageWriter) throws IOException { + this.columnDesc = columnDesc; this.storageWriter = storageWriter; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public void put(String value) throws IOException { if (null == value) { value = ""; @@ -122,13 +143,20 @@ public class StringColumn { } private static class CStringReader implements StringColumnReader { + private final ColumnDesc columnDesc; private final StorageReader storageReader; private long position = 0; - public CStringReader(StorageReader storageReader) throws IOException { + public CStringReader(ColumnDesc columnDesc, StorageReader storageReader) throws IOException { + this.columnDesc = columnDesc; this.storageReader = storageReader; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public String get() throws IOException { StringBuilder sb = new StringBuilder(); byte b; @@ -169,13 +197,20 @@ public class StringColumn { private static class TxtStringWriter implements StringColumnWriter { + private final ColumnDesc columnDesc; private final StorageWriter storageWriter; private long position = 0; - public TxtStringWriter(StorageWriter storageWriter) throws IOException { + public TxtStringWriter(ColumnDesc columnDesc, StorageWriter storageWriter) throws IOException { + this.columnDesc = columnDesc; this.storageWriter = storageWriter; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public void put(String value) throws IOException { if (null == value) { value = ""; @@ -198,13 +233,20 @@ public class StringColumn { } private static class TxtStringReader implements StringColumnReader { + private final ColumnDesc columnDesc; private final StorageReader storageReader; private long position = 0; - public TxtStringReader(StorageReader storageReader) throws IOException { + public TxtStringReader(ColumnDesc columnDesc, StorageReader storageReader) throws IOException { + this.columnDesc = columnDesc; this.storageReader = storageReader; } + @Override + public ColumnDesc columnDesc() { + return columnDesc; + } + public String get() throws IOException { StringBuilder sb = new StringBuilder(); byte b; diff --git a/code/libraries/slop/java/nu/marginalia/slop/desc/SlopTable.java b/code/libraries/slop/java/nu/marginalia/slop/desc/SlopTable.java index 3d018eca..3933b2d1 100644 --- a/code/libraries/slop/java/nu/marginalia/slop/desc/SlopTable.java +++ b/code/libraries/slop/java/nu/marginalia/slop/desc/SlopTable.java @@ -51,14 +51,14 @@ public class SlopTable implements AutoCloseable { public void close() throws IOException { - Set positions = new HashSet<>(); + Map> positions = new HashMap<>(); for (ColumnReader reader : readerList) { - positions.add(reader.position()); + positions.computeIfAbsent(reader.position(), k -> new ArrayList<>()).add(reader.columnDesc()); reader.close(); } for (ColumnWriter writer : writerList) { - positions.add(writer.position()); + positions.computeIfAbsent(writer.position(), k -> new ArrayList<>()).add(writer.columnDesc()); writer.close(); } @@ -68,14 +68,15 @@ public class SlopTable implements AutoCloseable { // read or written to one of the columns. This is likely a bug, // but not necessarily a severe one, so we just log a warning. - if (positions.remove(0L) && !positions.isEmpty()) { - logger.warn("Zero position found in one of the tables, this is likely development debris"); + var zeroPositions = Objects.requireNonNullElseGet(positions.remove(0L), List::of); + if (!zeroPositions.isEmpty() && !positions.isEmpty()) { + logger.warn("Zero position found in {}, this is likely development debris", zeroPositions); } // If there are more than one position and several are non-zero, then we haven't maintained the // position correctly between the columns. This is a disaster, so we throw an exception. if (positions.size() > 1) { - throw new IllegalStateException("Expected only one reader position, was " + positions); + throw new IllegalStateException("Expected only one reader position, found " + positions); } for (var table : columnGroups.values()) { diff --git a/code/libraries/slop/test/nu/marginalia/slop/desc/SlopTableTest.java b/code/libraries/slop/test/nu/marginalia/slop/desc/SlopTableTest.java new file mode 100644 index 00000000..b55220f9 --- /dev/null +++ b/code/libraries/slop/test/nu/marginalia/slop/desc/SlopTableTest.java @@ -0,0 +1,215 @@ +package nu.marginalia.slop.desc; + +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class SlopTableTest { + Path tempDir; + + @BeforeEach + void setup() throws IOException { + tempDir = Files.createTempDirectory(getClass().getSimpleName()); + } + + @AfterEach + void cleanup() { + try { + Files.walk(tempDir) + .sorted(this::deleteOrder) + .forEach(p -> { + try { + if (Files.isRegularFile(p)) { + System.out.println("Deleting " + p + " " + Files.size(p)); + } + Files.delete(p); + } catch (IOException e) { + throw new RuntimeException(e); + } + }); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + int deleteOrder(Path a, Path b) { + if (Files.isDirectory(a) && !Files.isDirectory(b)) { + return 1; + } else if (!Files.isDirectory(a) && Files.isDirectory(b)) { + return -1; + } else { + return a.getNameCount() - b.getNameCount(); + } + } + + @Test + public void testEmpty() throws IOException { + SlopTable slopTable = new SlopTable(); + slopTable.close(); + } + + @Test + public void testPositionsGood() throws IOException { + var name1 = new ColumnDesc<>("test1", + 0, + ColumnFunction.DATA, + ColumnType.INT_LE, + StorageType.PLAIN + ); + var name2 = new ColumnDesc<>("test2", + 0, + ColumnFunction.DATA, + ColumnType.INT_LE, + StorageType.PLAIN + ); + + try (SlopTable writerTable = new SlopTable()) { + var column1 = name1.create(writerTable, tempDir); + var column2 = name2.create(writerTable, tempDir); + + column1.put(42); + column2.put(43); + } + + + try (SlopTable readerTable = new SlopTable()) { + var column1 = name1.open(readerTable, tempDir); + var column2 = name2.open(readerTable, tempDir); + + assertEquals(42, column1.get()); + assertEquals(43, column2.get()); + } + } + + + @Test + public void testPositionsMisaligned() throws IOException { + var name1 = new ColumnDesc<>("test1", + 0, + ColumnFunction.DATA, + ColumnType.INT_LE, + StorageType.PLAIN + ); + var name2 = new ColumnDesc<>("test2", + 0, + ColumnFunction.DATA, + ColumnType.INT_LE, + StorageType.PLAIN + ); + + boolean sawException = false; + try (SlopTable writerTable = new SlopTable()) { + var column1 = name1.create(writerTable, tempDir); + var column2 = name2.create(writerTable, tempDir); + + column1.put(42); + column2.put(43); + column2.put(44); + } + catch (Exception ex) { + ex.printStackTrace(); + sawException = true; + } + assertEquals(true, sawException); + + } + + + // Sanity check for the implementation of position() in the column classes + @Test + public void testPositionsMegatest() throws IOException { + var byteCol = new ColumnDesc<>("byte", ColumnType.BYTE, StorageType.PLAIN); + var charCol = new ColumnDesc<>("char", ColumnType.CHAR_LE, StorageType.PLAIN); + var intCol = new ColumnDesc<>("int", ColumnType.INT_LE, StorageType.PLAIN); + var longCol = new ColumnDesc<>("long", ColumnType.LONG_LE, StorageType.PLAIN); + var floatCol = new ColumnDesc<>("float", ColumnType.FLOAT_LE, StorageType.PLAIN); + var doubleCol = new ColumnDesc<>("double", ColumnType.DOUBLE_LE, StorageType.PLAIN); + var byteArrayCol = new ColumnDesc<>("byteArray", ColumnType.BYTE_ARRAY, StorageType.PLAIN); + var intArrayCol = new ColumnDesc<>("intArray", ColumnType.INT_ARRAY_LE, StorageType.PLAIN); + var longArrayCol = new ColumnDesc<>("longArray", ColumnType.LONG_ARRAY_LE, StorageType.PLAIN); + var cstringCol = new ColumnDesc<>("cstring", ColumnType.CSTRING, StorageType.PLAIN); + var txtStringCol = new ColumnDesc<>("txtString", ColumnType.TXTSTRING, StorageType.PLAIN); + var arrayStringCol = new ColumnDesc<>("arrayString", ColumnType.STRING, StorageType.PLAIN); + var varintCol = new ColumnDesc<>("varint", ColumnType.VARINT_LE, StorageType.PLAIN); + var enumCol = new ColumnDesc<>("enum", ColumnType.ENUM_LE, StorageType.PLAIN); + + try (SlopTable writerTable = new SlopTable()) { + var byteColumn = byteCol.create(writerTable, tempDir); + var charColumn = charCol.create(writerTable, tempDir); + var intColumn = intCol.create(writerTable, tempDir); + var longColumn = longCol.create(writerTable, tempDir); + var floatColumn = floatCol.create(writerTable, tempDir); + var doubleColumn = doubleCol.create(writerTable, tempDir); + var byteArrayColumn = byteArrayCol.create(writerTable, tempDir); + + var intArrayColumn = intArrayCol.create(writerTable, tempDir); + var longArrayColumn = longArrayCol.create(writerTable, tempDir); + var cstringColumn = cstringCol.create(writerTable, tempDir); + var txtStringColumn = txtStringCol.create(writerTable, tempDir); + var arrayStringColumn = arrayStringCol.create(writerTable, tempDir); + var enumColumn = enumCol.create(writerTable, tempDir); + var varintColumn = varintCol.create(writerTable, tempDir); + + byteColumn.put((byte) 42); + charColumn.put('a'); + intColumn.put(42); + longColumn.put(42L); + floatColumn.put(42.0f); + doubleColumn.put(42.0); + + byteArrayColumn.put(new byte[] { 42, 43, 44 }); + intArrayColumn.put(new int[] { 42, 43, 44 }); + longArrayColumn.put(new long[] { 42, 43, 44 }); + + cstringColumn.put("Hello"); + txtStringColumn.put("Hello"); + arrayStringColumn.put("Hello"); + enumColumn.put("Hello"); + + varintColumn.put(10000000); + } + + try (SlopTable readerTable = new SlopTable()) { + var byteColumn = byteCol.open(readerTable, tempDir); + var charColumn = charCol.open(readerTable, tempDir); + var intColumn = intCol.open(readerTable, tempDir); + var longColumn = longCol.open(readerTable, tempDir); + var floatColumn = floatCol.open(readerTable, tempDir); + var doubleColumn = doubleCol.open(readerTable, tempDir); + var byteArrayColumn = byteArrayCol.open(readerTable, tempDir); + var intArrayColumn = intArrayCol.open(readerTable, tempDir); + var longArrayColumn = longArrayCol.open(readerTable, tempDir); + var cstringColumn = cstringCol.open(readerTable, tempDir); + var txtStringColumn = txtStringCol.open(readerTable, tempDir); + var arrayStringColumn = arrayStringCol.open(readerTable, tempDir); + var enumColumn = enumCol.open(readerTable, tempDir); + var varintColumn = varintCol.open(readerTable, tempDir); + + assertEquals(42, byteColumn.get()); + assertEquals('a', charColumn.get()); + assertEquals(42, intColumn.get()); + assertEquals(42L, longColumn.get()); + assertEquals(42.0f, floatColumn.get()); + assertEquals(42.0, doubleColumn.get()); + + assertArrayEquals(new byte[] {42, 43, 44}, byteArrayColumn.get()); + assertArrayEquals(new int[] {42, 43, 44}, intArrayColumn.get()); + assertArrayEquals(new long[] {42, 43, 44}, longArrayColumn.get()); + + assertEquals("Hello", cstringColumn.get()); + assertEquals("Hello", txtStringColumn.get()); + assertEquals("Hello", arrayStringColumn.get()); + assertEquals("Hello", enumColumn.get()); + + assertEquals(10000000, varintColumn.get()); + } + + } +}