feat: Utilities to assist in retrieving data from tables

Util/src/main/java/io/deephaven/util/type/TypeUtils.java

@@ -339,8 +339,8 @@ public static double[] toDoubleArray(double[] array) {
 
     public static boolean isConvertibleToPrimitive(Class<?> type) {
         final Class<?> unboxedType = TypeUtils.getUnboxedType(type);
-        return unboxedType != null && unboxedType != boolean.class; // TODO: isConvertibleToPrimitive(Boolean.class) ==
-                                                                    // false ???
+        // (Note: Booleans must be boxed because primitive boolean does not support null.)
+        return unboxedType != null && unboxedType != boolean.class;
     }
 
     public static boolean isBoxedType(Class<?> exprType) {
@@ -628,4 +628,158 @@ public static long unbox(Long value) {
     public static short unbox(Short value) {
         return (value == null ? NULL_SHORT : value);
     }
+
+    public static Byte[] box(byte[] values) {
+        if (values == null) {
+            return null;
+        }
+        final Byte[] boxed = new Byte[values.length];
+        for (int ii = 0; ii < values.length; ii++) {
+            boxed[ii] = box(values[ii]);
+        }
+        return boxed;
+    }
+
+    public static Character[] box(char[] values) {
+        if (values == null) {
+            return null;
+        }
+        final Character[] boxed = new Character[values.length];
+        for (int ii = 0; ii < values.length; ii++) {
+            boxed[ii] = box(values[ii]);
+        }
+        return boxed;
+    }
+
+    public static Double[] box(double[] values) {
+        if (values == null) {
+            return null;
+        }
+        final Double[] boxed = new Double[values.length];
+        for (int ii = 0; ii < values.length; ii++) {
+            boxed[ii] = box(values[ii]);
+        }
+        return boxed;
+    }
+
+    public static Float[] box(float[] values) {
+        if (values == null) {
+            return null;
+        }
+        final Float[] boxed = new Float[values.length];
+        for (int ii = 0; ii < values.length; ii++) {
+            boxed[ii] = box(values[ii]);
+        }
+        return boxed;
+    }
+
+    public static Integer[] box(int[] values) {
+        if (values == null) {
+            return null;
+        }
+        final Integer[] boxed = new Integer[values.length];
+        for (int ii = 0; ii < values.length; ii++) {
+            boxed[ii] = box(values[ii]);
+        }
+        return boxed;
+    }
+
+    public static Long[] box(long[] values) {
+        if (values == null) {
+            return null;
+        }
+        final Long[] boxed = new Long[values.length];
+        for (int ii = 0; ii < values.length; ii++) {
+            boxed[ii] = box(values[ii]);
+        }
+        return boxed;
+    }
+
+    public static Short[] box(short[] values) {
+        if (values == null) {
+            return null;
+        }
+        final Short[] boxed = new Short[values.length];
+        for (int ii = 0; ii < values.length; ii++) {
+            boxed[ii] = box(values[ii]);
+        }
+        return boxed;
+    }
+
+    public static byte[] unbox(Byte[] values) {
+        if (values == null) {
+            return null;
+        }
+        final byte[] unboxed = new byte[values.length];
+        for (int ii = 0; ii < values.length; ii++) {
+            unboxed[ii] = unbox(values[ii]);
+        }
+        return unboxed;
+    }
+
+    public static char[] unbox(Character[] values) {
+        if (values == null) {
+            return null;
+        }
+        final char[] unboxed = new char[values.length];
+        for (int ii = 0; ii < values.length; ii++) {
+            unboxed[ii] = unbox(values[ii]);
+        }
+        return unboxed;
+    }
+
+    public static double[] unbox(Double[] values) {
+        if (values == null) {
+            return null;
+        }
+        final double[] unboxed = new double[values.length];
+        for (int ii = 0; ii < values.length; ii++) {
+            unboxed[ii] = unbox(values[ii]);
+        }
+        return unboxed;
+    }
+
+    public static float[] unbox(Float[] values) {
+        if (values == null) {
+            return null;
+        }
+        final float[] unboxed = new float[values.length];
+        for (int ii = 0; ii < values.length; ii++) {
+            unboxed[ii] = unbox(values[ii]);
+        }
+        return unboxed;
+    }
+
+    public static int[] unbox(Integer[] values) {
+        if (values == null) {
+            return null;
+        }
+        final int[] unboxed = new int[values.length];
+        for (int ii = 0; ii < values.length; ii++) {
+            unboxed[ii] = unbox(values[ii]);
+        }
+        return unboxed;
+    }
+
+    public static long[] unbox(Long[] values) {
+        if (values == null) {
+            return null;
+        }
+        final long[] unboxed = new long[values.length];
+        for (int ii = 0; ii < values.length; ii++) {
+            unboxed[ii] = unbox(values[ii]);
+        }
+        return unboxed;
+    }
+
+    public static short[] unbox(Short[] values) {
+        if (values == null) {
+            return null;
+        }
+        final short[] unboxed = new short[values.length];
+        for (int ii = 0; ii < values.length; ii++) {
+            unboxed[ii] = unbox(values[ii]);
+        }
+        return unboxed;
+    }
 }

data-adapter/build.gradle

@@ -0,0 +1,29 @@
+plugins {
+    id 'io.deephaven.project.register'
+    id 'java-library'
+}
+
+dependencies {
+    api project(':engine-api')
+    api project(':engine-table')
+    api project(':engine-function')
+
+    api 'com.fasterxml.jackson.core:jackson-databind:2.13.4'
+
+    implementation project(':log-factory')
+    implementation libs.commons.lang3
+
+    testRuntimeOnly project(path: ':configs')
+    testRuntimeOnly project(path: ':test-configs')
+
+    testImplementation TestTools.projectDependency(project, 'engine-table')
+    testImplementation project(path: ':Base', configuration: 'tests')
+
+    testRuntimeOnly project(':log-to-slf4j')
+}
+
+repositories {
+    mavenCentral()
+}
+
+TestTools.addEngineOutOfBandTest(project)

data-adapter/gradle.properties

@@ -0,0 +1 @@
+io.deephaven.project.ProjectType=JAVA_PUBLIC

data-adapter/src/main/java/io/deephaven/dataadapter/ChunkRetrievalUtil.java

@@ -0,0 +1,147 @@
+//
+// Copyright (c) 2016-2024 Deephaven Data Labs and Patent Pending
+//
+package io.deephaven.dataadapter;
+
+import io.deephaven.chunk.*;
+import io.deephaven.chunk.attributes.Values;
+import io.deephaven.engine.rowset.RowSequence;
+import io.deephaven.engine.table.ChunkSource;
+import io.deephaven.engine.table.ColumnSource;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+class ChunkRetrievalUtil {
+
+    @NotNull
+    static <T> ObjectChunk<T, ?> getObjChunkForKeys(
+            final ColumnSource<T> columnSource,
+            final RowSequence rowSequence,
+            final ChunkSource.GetContext context,
+            final boolean usePrev) {
+        return getChunkForKeys(
+                columnSource,
+                rowSequence,
+                context,
+                usePrev).asObjectChunk();
+    }
+
+    @NotNull
+    static CharChunk<? extends Values> getCharChunkForKeys(
+            final ColumnSource<Character> columnSource,
+            final RowSequence rowSequence,
+            final ChunkSource.GetContext context,
+            final boolean usePrev) {
+        return getChunkForKeys(
+                columnSource,
+                rowSequence,
+                context,
+                usePrev).asCharChunk();
+    }
+
+    @NotNull
+    static ByteChunk<? extends Values> getByteChunkForKeys(
+            final ColumnSource<Byte> columnSource,
+            final RowSequence rowSequence,
+            final ChunkSource.GetContext context,
+            final boolean usePrev) {
+        return getChunkForKeys(
+                columnSource,
+                rowSequence,
+                context,
+                usePrev).asByteChunk();
+    }
+
+    @NotNull
+    static ShortChunk<? extends Values> getShortChunkForKeys(
+            final ColumnSource<Short> columnSource,
+            final RowSequence rowSequence,
+            final ChunkSource.GetContext context,
+            final boolean usePrev) {
+        return getChunkForKeys(
+                columnSource,
+                rowSequence,
+                context,
+                usePrev).asShortChunk();
+    }
+
+    @NotNull
+    static IntChunk<? extends Values> getIntChunkForKeys(
+            final ColumnSource<Integer> columnSource,
+            final RowSequence rowSequence,
+            final ChunkSource.GetContext context,
+            final boolean usePrev) {
+        return getChunkForKeys(
+                columnSource,
+                rowSequence,
+                context,
+                usePrev).asIntChunk();
+    }
+
+    @NotNull
+    static FloatChunk<? extends Values> getFloatChunkForKeys(
+            final ColumnSource<Float> columnSource,
+            final RowSequence rowSequence,
+            final ChunkSource.GetContext context,
+            final boolean usePrev) {
+        return getChunkForKeys(
+                columnSource,
+                rowSequence,
+                context,
+                usePrev).asFloatChunk();
+    }
+
+    @NotNull
+    static LongChunk<? extends Values> getLongChunkForKeys(
+            final ColumnSource<Long> columnSource,
+            final RowSequence rowSequence,
+            final ChunkSource.GetContext context,
+            final boolean usePrev) {
+        return getChunkForKeys(
+                columnSource,
+                rowSequence,
+                context,
+                usePrev).asLongChunk();
+    }
+
+    @NotNull
+    static DoubleChunk<? extends Values> getDoubleChunkForKeys(
+            final ColumnSource<Double> columnSource,
+            final RowSequence rowSequence,
+            final ChunkSource.GetContext context,
+            final boolean usePrev) {
+        return getChunkForKeys(
+                columnSource,
+                rowSequence,
+                context,
+                usePrev).asDoubleChunk();
+    }
+
+    @NotNull
+    static BooleanChunk<? extends Values> getBooleanChunkForKeys(
+            final ColumnSource<Boolean> columnSource,
+            final RowSequence rowSequence,
+            final ChunkSource.GetContext context,
+            final boolean usePrev) {
+        return getChunkForKeys(
+                columnSource,
+                rowSequence,
+                context,
+                usePrev).asBooleanChunk();
+    }
+
+
+    @NotNull
+    static <T> Chunk<? extends Values> getChunkForKeys(
+            final ColumnSource<T> columnSource,
+            final RowSequence rowSequence,
+            final ChunkSource.GetContext context, boolean usePrev) {
+        return Objects.requireNonNull(usePrev ? columnSource.getPrevChunk(context, rowSequence)
+                : columnSource.getChunk(context, rowSequence));
+    }
+
+
+    private ChunkRetrievalUtil() {}
+
+}